多线程

多进程

multiprocessing

From multiprocessint import Process
可以通过Process来构造一个子进程，
P=Process(target=fun,args=(args))
再通过p.start()来启动子进程
再通过p.join()方法来使的子进程运行结束后再执行父进程

使用multiprocessing创建进程

#!/usr/bin/env python
import multiprocessing
import os
def do_this(what):
	whoami(what)
def whoami(what):
	print ('process %s says: %s'%(os.getpid(),what))
if __name__=='__main__':
	whoami("i am the main program")
	for n in range(3):
		p=multiprocessing.Process(target=do_this,args=("i am function %s"%n,))
		p.start()

运行结果：

[root@wish1 420]# python a.py 
process 1592 says: i am the main program
process 1595 says: i am function 2
process 1594 says: i am function 1
process 1593 says: i am function 0

使用telminate()终止进程

下面的例子，我们的进程会一直技术到万，每次计数之后都会等待1秒并打印出相关信息，然而我们的主程序只会保持5秒的耐心，之后会终止进程

#!/usr/bin/env python
import multiprocessing
import time
import os
def whoami(name):
	print ("i am  %s,in process %s"%(name,os.getpid()))
def loopy(name):
	whoami(name)
	start=1
	stop=100000
	for num in range(start,stop):
		print ("\tNumber %s of %s. Honk"%(num,stop))
		time.sleep(1)
if __name__=="__main__":
	whoami("main")
	p=multiprocessing.Process(target=loopy,args=("loopy",))
	p.start()
	time.sleep(5)
	p.terminate()

运行结果

[root@wish1 420]# python b.py 
i am  main,in process 1622
i am  loopy,in process 1623
	Number 1 of 100000. Honk
	Number 2 of 100000. Honk
	Number 3 of 100000. Honk
	Number 4 of 100000. Honk
	Number 5 of 100000. Honk

如果需要多个子进程时可以考虑使用进程池来管理
from multiprocessing import Pool

root@wish1 420]# cat 2.py 
#!/usr/bin/env python
from multiprocessing import Pool
import os,time
def long_time_task(name):
	print "run task %s %s..."%(name,os.getpid())
	start=time.time()
	time.sleep(2)
	end=time.time()
	print 'task %s run %0.2f seconds'%(name,(end-start))
if __name__=='__main__'：
	print "parent process %s "%os.getpid()
	p=Pool()
	for i in range(4):
		p.apply_async(long_time_task,args=(i,))
	print 'waiting for all subprocess done...'
	p.close()
	p.join()
	print 'All subprocess done'

Pool创建子进程的方法和Process不同，是通过
P.apply_async(func,args=(args))来实现的，个池子里能同时运行的任务是取决你电脑的cpu数量
码中的p.close()是关掉进程池子，是不再向里面添加进程了，对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
当时也可以是实例pool的时候给它定义一个进程的多少
如果上面的代码中p=Pool(5)那么所有的子进程就可以同时进行

root@wish1 420]# cat 3.py 
#!/usr/bin/env python
from multiprocessing import Pool
def say_hi(name):
	print "hello my name is %s"%name
pool=Pool(processes=5)
result=[]
for i in range(5):
	result.append(pool.apply_async(say_hi,[i]))
for i in result:
	i.get()

threading多线程

[root@wish1 420]# cat thread.py 
#!/usr/bin/env python
import threading
def do_this(what):
	whoami(what)
def whoami(what):
	print('Threading %s says: %s'%(threading.current_thread(),what))
if __name__=="__main__":
	whoami("i am the main program")
	for i in range(4):
		p=threading.Thread(target=do_this,args=("i am function %s"%i,))
		p.start()
root@wish1 420]# python thread.py 
Threading <_MainThread(MainThread, started 139966398875392)> says: i am the main program
Threading <Thread(Thread-1, started 139966287800064)> says: i am function 0
Threading <Thread(Thread-2, started 139966206179072)> says: i am function 1
Threading <Thread(Thread-3, started 139966287800064)> says: i am function 2
Threading <Thread(Thread-4, started 139966206179072)> says: i am function 3