Python之多线程和多进程

　　

一、多线程

1、顺序执行单个线程，注意要顺序执行的话，需要用join。

 #coding=utf-8

 from threading import Thread
 import time

 def my_counter():
     i = 0
     for _ in range(100000000):
         i = i + 1
     return True

 def main():
     thread_array = {}
     start_time = time.time()
     for tid in range(2):
         t = Thread(target=my_counter)
         t.start()
         # join阻塞下个线程，除非当前线程执行完毕
         t.join()
     end_time = time.time()
     print("Total time: {}".format(end_time - start_time))

 if __name__ == '__main__':

　执行结果：　

2、同时执行两个并发线程

 #coding=utf-8

 from threading import Thread
 import time

 def prn_obj(obj):
     return '\n'.join(['%s:%s' % item for item in obj.__dict__.items()])

 def my_counter():
     i = 0
     for _ in range(100000000):
         i = i + 1
     return True

 def main():
     thread_array = {}
     start_time = time.time()
     for tid in range(2):
         t = Thread(target=my_counter)
         t.start()
         thread_array[tid] = t
     for i in range(2):
         thread_array[i].join()
         # print("thread type: {}".format(prn_obj(thread_array[i])))
         print("thread type: {}".format(thread_array[i].name))
     end_time = time.time()
     print("Total time: {}".format(end_time - start_time))

 if __name__ == '__main__':
     main()

下面是用了打印所有属性的方法，这个方法代码中注释了，可重复利用的代码块

二、多进程

1、multiprocessing

multiprocessing是跨平台版本的多进程模块，它提供了一个Process类来代表一个进程对象，下面是示例嗲吗

import os
if __name__=='__main__':
    print 'Process (%s) start...' % os.getpid()
    pid = os.fork()
    print pid
    if pid==0:
            print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())
    else:
            print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)

这个程序如果用单进程写则需要执行10秒以上的时间，而用多进程则启动10个进程并行执行，只需要用1秒多的时间。

在python中建议使用多进程而不是多线程，因为在python的多线程中有个全局解释器锁，这样在做并发效率会不是很高。

进程和进程直接可以用不同的全局解释器锁，可以提高程序效率。

2、进程间通信Queue

进程和进程之前是独立的，如果需要通信就需要Queue创建的对象来处理

 from multiprocessing import Process,Queue
 import time

 def write(q):
     for i in ['A','B','C','D','E']:
         print('Put %s to queue' % i)
         q.put(i)
         time.sleep(0.5)

 def read(q):
     while True:
         v = q.get(True)
         print('get %s form queue' %v)

 if __name__ == '__main__':
     q = Queue()
     pw = Process(target=write,args=(q,))
     pr = Process(target=read,args=(q,))
     pw.start()
     pr.start()
     pr.join()
     pr.terminate()

3、进程池Pool

 #coding=utf-8

 from multiprocessing import Pool
 import time

 def f(x):
     print x*x
     time.sleep(2)
     return x*x

 if __name__ == '__main__':
     '''定义启动的进程数量'''
     pool = Pool(processes=5)
     res_list = []

     for i in range(10):
         '''
         以异步并行的方式启动进程，如果要同步等待的方式，
         可以在每次启动进程之后调用res.get()方法
         也可以使用Pool.appley
         '''
         res = pool.apply_async(f,[i,])
         print('--------:',i)
         res_list.append(res)
     pool.close()
     pool.join()
     for r in res_list:
         print "result",(r.get(timeout=5))

三、多线程与多进程的对比

在一般情况下多个进程的内存资源是相互独立的，而多线程可以共享同一个进程中的内存资源

 #coding=utf-8

 from multiprocessing import Process
 import threading
 import time
 lock = threading.Lock()

 def run(info_list,n):
     lock.acquire()
     info_list.append(n)
     lock.release()
     print('%s' % info_list)

 if __name__ == '__main__':
     info = []
     for i in range(10):
         # target为子进程执行的函数，args为需要给函数传递的参数
         p = Process(target=run,args=[info,i])
         p.start()
         p.join()
     time.sleep(1)#这里为了输出整齐让主进程的执行等一下子进程
     print('-------------------threading---------------------')
     for i in xrange(1,10):
         p = threading.Thread(target=run,args=[info,i])
         p.start()
         p.join()