7、进程与线程

1、多进程

A：Unix/Linux进程（windows不支持）

 

import os # fork创建一个子进程 pid = os.fork() # 子进程返回0 if pid == 0: print 'this is child : %s ,parent:%s' % (os.getpid(),os.ppid()) else print 'this is parent: %s' % os.getpid()

 

B：multiprocessing 夸平台支持多进程

 

#coding=utf-8 from multiprocessing import Process import os def myProc(name): print 'processing name :%s :%s' %(name,os.getpid()) if __name__ == '__main__': print 'Parent process : %s' % os.getpid() # 创建一个进程 # target 进程启动时运行的方法，args第一个参数是进程名称 pro = Process(target=myProc,args=('test',)) pro.start() # 启动子进程 运行myPro方法 pro.join() # 子进程运行完后再往下执行 print 'end'

 

C：Pool 启动大量进程

 

from multiprocessing import Pool import os,time,random def myPro(name): print 'Run task %s (%s)...' % (name, os.getpid()) start = time.time() # 进程休眠 time.sleep(random.random() * 2) # 秒 end = time.time() print 'Task %s runs %0.2f seconds.' % (name, (end - start)) if __name__ == '__main__': # 设置同时可以运行多个进程,默认cpu个数 p = Pool() for i in range(5): # 创建进程，并运行进程 p.apply_async(myPro,args=(i,)) print '----------start-------------' #time.sleep(30) p.close() # 保证之后不再添加新的进程 p.join() # 子进程都结束后再运行下边的程序 print '----------end---------------'

 

D：进程之间的通信

 

# Pipes一对一通信，效率高，Queue基于Pipes,可以多对多通信 # 以Queue为例 from multiprocessing import Process,Queue import os,time,random # 写 def write(q,name): for v in ['1','2','3','4','5','6','7','8','9','0']: q.put(v) print 'who: %s write %s' % (name,v) time.sleep(random.random()*2) # 读 def read(q,name): while True: #时刻在读取Queue中数据 print 'who: %s read %s' % (name,q.get(True)) time.sleep(random.random()*1) if __name__ == '__main__': q = Queue() # 写 进程 w = Process(target=write,args=(q,'w')) # 读 进程 r = Process(target=read,args=(q,'r')) w.start() r.start() w.join() r.terminate() # 强制停止进程

 

2、多线程（进程中有一个或多个线程）

A：threading (对thread进行封装)

 

import time,threading # 线程执行的代码 def mydef(): print 'who run : %s' % threading.current_thread().name n = 0 while n < 5 : n = n + 1 print 'thread %s --- %d' % (threading.current_thread().name,n) time.sleep(1) print 'end: %s' % threading.current_thread().name if __name__ == '__main__': t1 = threading.Thread(target=mydef,name='thread_1') t2 = threading.Thread(target=mydef,name='thread_2') t1.start() t2.start() t1.join() t2.join()

 

B：Lock (线程锁，避免变量同时被多个线程操作)

 

import time,threading number = 0 def change(n): # 该数据同时被两个线程操作，造成数据的混乱 global number number = number + n number = number - n def run(n): for i in range(1000): change(n) print number ,'\n' if __name__ == '__main__': thread1 = threading.Thread(target=run,args=(5,)) thread2 = threading.Thread(target=run,args=(8,)) thread1.start() thread2.start() thread1.join() thread2.join() print number # 使用 Lock() 实现变量的同步，将上边的run方法修改 # 即 全局变量的操作必须加锁 def run2(n): for i in range(1000): # 将该代码段锁住，是能同时被一个线程访问 lock.acquire() try: change(n) finally: # 释放线程锁 lock.release() print number ,'\n'

 

C：多核CPU

        多核可以同时执行多个线程。

        但是在Python中，有GIL（Global Interpreter Lock）锁，故线程被上锁，是交替运行的。

 

        所以，在多核CPU中运用线程是徒劳的。

 

3、ThreadLocal

在线程中， 局部变量的传递是通过方法的参数传递的，但是调用多层的方法时，会很麻烦。

使用ThreadLocal可以解决局部变量传递的问题。

import threading # local是一个dict 键值对 local = threading.local() def run(name): # 设置传递局部变量参数 local.name = name # 因为是局部变量，所以不需要设置锁 for i in range(1000): addB() def addB(): # 获取局部变量参数 name = local.name + '+B' print '%s = %s \n' % (threading.current_thread().name,name) if __name__ == '__main__': p1 = threading.Thread(target=run,args=('p1',),name='thread_1') p2 = threading.Thread(target=run,args=('p2',),name='thread_2') p1.start() p2.start() p1.join() p2.join()