python 的线程和进程

奥德赛F9

　　线程
　　线程是操作系统可以调度的最小单元。
　　线程：一堆指令的集合，包含在进程之中
　　数据临时存入内存中，程序关闭时，内存清空。
　　硬盘的读写速度<内存<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