一.python线程
线程用于提供线程相关的操作，线程是应用程序中工作的最小单元。
＃！/ usr / bin / env python
＃ - * - coding：utf-8 - * -
import threading
import time
def show(arg)：
time.sleep(1)print'thread
'+ str(arg)
for我在范围(10)中：
t = threading.Thread(target = show，args =(i，))
t.start()print'main
thread stop
上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。
更多方法：
start线程准备就绪，等待CPU调度
setName为线程设置名称
getName获取线程名称
setDaemon设置为后台线程或前台线程(默认)
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止加入逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义，run线程被执行cpu调度后自动执行线程对象的运行方法
import threading
import time
class MyThread(threading.Thread):
def __init__(self,num):
threading.Thread.__init__(self)
self.num = num
def run(self):#定义每个线程要运行的函数
print("running on number:%s" %self.num)
time.sleep(3)
if __name__ == '__main__':
t1 = MyThread(1)
t2 = MyThread(2)
t1.start()
t2.start()
自定义线程类
二.线程锁(锁，RLOCK)
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
gl_num = 0
def show(arg):
global gl_num
time.sleep(1)
gl_num +=1
print gl_num
for i in range(10):
t = threading.Thread(target=show, args=(i,))
t.start()
print 'main thread stop'
未使用锁
互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。
三.信号量(信号量)
import threading,time
def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread:%s" %n)
semaphore.release()
if __name__ == '__main__':
num= 0
semaphore = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
for i in range(20):
t = threading.Thread(target=run,args=(i,))
t.start()
四.事件(事件)
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法set，wait，clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为False，那么当程序执行event.wait方法时就会阻塞，如果“Flag”值为True，那么event.wait方法时便不再阻塞。
clear：将“Flag”设置为False
set：将“Flag”设置为True
def condition_func():
ret = False
inp = input('>>>')
if inp == '1':
ret = True
return ret
def run(n):
con.acquire()
con.wait_for(condition_func)
print("run the thread:%s" %n)
con.release()
if __name__ == '__main__':
con = threading.Condition()
for i in range(10):
t = threading.Thread(target=run, args=(i,))
t.start()
六.Timer
七.python进程
八.进程数据共享
进程各自持有一份数据，默认无法共享数据
#!/usr/bin/env python
#coding:utf-8
from multiprocessing import Process
from multiprocessing import Manager
import time
li = []
def foo(i):
li.append(i)
print 'say hi',li
for i in range(10):
p = Process(target=foo,args=(i,))
p.start()
print 'ending',li
进程间默认无法数据共享
'c': ctypes.c_char, 'u': ctypes.c_wchar,
'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
'h': ctypes.c_short, 'H': ctypes.c_ushort,
'i': ctypes.c_int, 'I': ctypes.c_uint,
'l': ctypes.c_long, 'L': ctypes.c_ulong,
'f': ctypes.c_float, 'd': ctypes.c_double
类型对应表
from multiprocessing import Process, Queue
def f(i,q):
print(i,q.get())
if __name__ == '__main__':
q = Queue()
q.put("h1")
q.put("h2")
q.put("h3")
for i in range(10):
p = Process(target=f, args=(i,q,))
p.start()
Code
当创建进程时(非使用时)，共享数据会被拿到子进程中，当进程中执行完毕后，再赋值给原值。
九.进程池
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。
进程池中有两个方法：
申请
apply_async
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process,Pool
import time
def Foo(i):
time.sleep(2)
return i+100
def Bar(arg):
print arg
pool = Pool(5)
#print pool.apply(Foo,(1,))
#print pool.apply_async(func =Foo, args=(1,)).get()
for i in range(10):
pool.apply_async(func=Foo, args=(i,),callback=Bar)
print 'end'
pool.close()
pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭
)
