线程

线程是操作系统可以调度的最小单元。

线程：一堆指令的集合，包含在进程之中

数据临时存入内存中，程序关闭时，内存清空。

硬盘的读写速度<内存<CPU

每一个程序的内存是独立的，相互之间不能访问。

内存对各种资源管理的集合，就是进程。

进程如果要操作CPU，必须要创建线程。进程本身不具备执行的能力。必须依赖线程去操作CPU。一个进程至少要有一个线程。

所有在同一个进程里的线程是共享同一块内存空间的。

进程

一个程序执行的实例就是一个进程。

主线程启动子线程之后，相互也是独立的

子进程之间也是独立的，不能互相访问。子进程是完全从父进程的拷贝。

同一个进程的不同线程可以直接交流。两个进程如果通信，必须通过一个中间代理。

新的线程很容易创建，新的进程必须对其父进程进行一个拷贝。

一个线程可以控制和操作同一进程的其它线程。进程只能操作子进程。

对子线程的修改会影响同一进程的其它线程，因为内存是共享的。子进程的修改不会影响其它子进程。

import threading
def run(args):
    print "task：%s"%args
t1 = threading.Thread(target=run,args=(1,))
t2 = threading.Thread(target=run,args=(1,))
t1.start()
t2.start()# 并发的，多线程

#另一种写法
import threading
class Mythread(threading.thread):
    def __init__(self,n):
        super(Mythread,self).__init__()
        self.n = n
    def run(self):#必须是run
        print "run task",self.n
t1.getName()# 得到线程的名称 在start()之前设置
threading.current_thread()# 查看当前的线程
threading.active_count()# 
t1.isDaemon()# 判断是否是守护线程
t1.setDaemon(True)# 设置为守护线程
t1.join(5)# 等待子线程执行线束，线束后主程序继续执行（会变成串行）。参数为超时时间。
t1.run()# 线程被CPU调度后自动执行线程对象的run方法（target=run)
# 守护线程：主线程结束之后不会再等待守护线程，直接结束

GIL（全局解释器锁）

     python同一时间执行的线程只能只有一个（无论多少核）执行。假线程。因为不断的上下文切换，太快了，看上去像多线程。只有Cpython存在这种问题，未来pypy没有这种问题

     给线程加锁：l = threading.Lock(), 加 l.acquire() 加锁，l.release()释放锁.

     锁里面有其它的锁。为了区别不同的锁。加 threading.RLock() 递归锁。

信号量（semaphore)

    se = threading.BoundedSemaphore(5) 同一时间只能有5个线程同时运行，如果其中有一个线程运行结束，立刻会有新的线程加入，但是同一时间运行线程的数目依然是5个。

    se.acquire() 信号量上锁

    se.release() 信号量释放

事件（Event）

    事件是一个简单的同步对象，代表内部的一个标志。

    event =thread.Event()

    event.wait( ) #标志位没有设置，将卡在这里，设置之后就不阻塞了

    event.set( ) # 设定标志位

    event.clear( ) # 清空标志位

队列(queue)

    主要两个作用：解耦 使程序实现松耦合   提高处理效率

    队列：先进先出， 栈：后进后出

    import  Queue # 线程Queue

    que = Queue.Queue(maxsize=199) #maxsize设置队列大小

    que.put("1")

    que.put(‘2‘)

    que.get(block=True, timeout=1) # block取不到数据会不会卡住。timeout超时时间

    que.empty() # 是否为空

IO操作不占用CPU，计算占用CPU。python 的多线程不适合CPU密集操作型的任务，适合IO密集型的任务

多进程

import multiprocessing
import time

def run(name):
    time.sleep(2)
    print "task:",name
if __name__=="__main__":
    for p in range(10):
        p = multiprocessing.Process(target=run, args=("p",))
        p.start()

    Queue 进程Queue

    from multiprocessing import Queue, Process

    Pipe 管道

    from multiprocessing import Queue, Pipe

    parent_conn, child_conn = Pipe()

    Manager

    with Manager as manager:

        d = manager.dict() # 生成一个字典， 可在进程或线程间通讯

    进程也有锁的概念。Lock

    from multiprocessing import Pool, Process

        p = Poo(5) ＃进程池中的最大开启为５个

    进程池中的进程执行完毕之后再关闭，先close(), 再join()

    进程池有两个方法　apply(func=foo, args=(i,)) 串行，  apply_async(func=foo,args=(1,), callback=Bar) 异步

    callback:回调函数，每个进程执行结束之后都会执行即主进程调用回调函数，回调函数是主进程调用。Bar:用户定义的要执行函数

协程

    协程，又称微线程。协程是一种用户态的轻量级线程

    协程是用户自己控制的。cpu根本不知道。协程能保留上一次调用时的状态。每次过程重入时，就相当于进入上一次调用的状态。

好处：无需上下文切换的开销。改同一份数据不需要加锁(因为协程是单线程)

        高并发+高扩展性+低成本

缺点：无法利用多核资源(因为是单线程) 协程需要和进程配合才能运行在CPU上。（协程是跑在线程中的）

手动切换：

from greenlet import greenlet
def fun1():
    print "1"
    gr2.switch() # 切换到fun2
    print "2"
    gr2.switch()
    
def fun2():
    print "3"
    gr1.switch()
    print "4"
gr1 = greenlet(fun1) # 启动一个协程
gr2 = greenlet(fun2)

import gevent,time
start= time.time()
def fun1():
    print "1"
    gevent.sleep(2) 
    print "2"

    
def fun2():
    print "3"
    gevent.sleep(1)
    print "4"
gevent.joinall([
    gevent.spawn(fun1),
    gevent.spawn(fun2)]
)
# time.sleep(10)    
print "time :%s "%(time.time()-start) # 结果：1,3,4,2 time:2

python 的线程和进程