python 的线程和进程
线程线程是操作系统可以调度的最小单元。
线程：一堆指令的集合，包含在进程之中
数据临时存入内存中，程序关闭时，内存清空。
硬盘的读写速度<内存<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)
主要两个作用：解耦 使程序实现松耦合 提高处理效率
队列：先进先出， 栈：后进后出
importQueue # 线程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
页:
[1]