进程：程序的一次执行（程序载入内存，系统分配资源运行）。每个进程有自己的内存空间，数据栈等，进程之间可以进行通讯，但是不能共享信息。
线程：所有的线程运行在同一个进程中，共享相同的运行环境。每个独立的线程有一个程序入口，顺序执行序列和程序的出口。
线程的运行可以被强占，中断或者暂时被挂起（睡眠），让其他的线程运行。一个进程中的各个线程共享同一片数据空间。
多线程
import threading def thread_job():
print "this is added thread,number is {}".format(threading.current_thread()) def main():
added_thread = threading.Thread(target = thread_job) #添加线程
added_thread.start() #执行添加的线程 print threading.active_count() #当前已被激活的线程的数目
print threading.enumerate() #激活的是哪些线程
print threading.current_thread() #正在运行的是哪些线程 if __name__ == "__main__":
main()
this is added thread,number is <Thread(Thread-6, started 6244)>6
[<HistorySavingThread(IPythonHistorySavingThread, started 7588)>, <ParentPollerWindows(Thread-3, started daemon 3364)>, <Heartbeat(Thread-5, started daemon 3056)>, <_MainThread(MainThread, started 1528)>, <Thread(Thread-6, started 6244)>, <Thread(Thread-4, started daemon 4700)>]
<_MainThread(MainThread, started 1528)>
#join 功能 等到线程执行完之后 再回到主线程中去
import threading
import time
def T1_job():
print "T1 start\n"
for i in range(10):
time.sleep(0.1)
print "T1 finish"
def T2_job():
print 'T2 start'
print 'T2 finish' def main():
thread1 = threading.Thread(target = T1_job) #添加线程
thread2 = threading.Thread(target = T2_job)
thread1.start() #执行添加的线程
thread2.start() thread1.join()
thread2.join()
print 'all done\n' if __name__ == "__main__":
main() T1 start
T2 start
T2 finish T1 finish
all done
#queue 多线程各个线程的运算的值放到一个队列中，到主线程的时候再拿出来,以此来代替
#return的功能，因为在线程是不能返回一个值的
import time
import threading
from Queue import Queue def job(l,q):
q.put([i**2 for i in l]) def multithreading(data):
q = Queue()
threads = []
for i in xrange(4):
t = threading.Thread(target = job,args = (data[i],q))
t.start()
threads.append(t)
for thread in threads:
thread.join()
results = []
for _ in range(4):
results.append(q.get())
print results if __name__ == "__main__":
data = [[1,2,3],[4,5,6],[3,4,3],[5,5,5]]
multithreading(data) [[1, 4, 9], [16, 25, 36], [9, 16, 9], [25, 25, 25]]
#多线程的锁
import threading
import time def T1_job():
global A,lock
lock.acquire() for i in xrange(10):
A += 1
print 'T1_job',A lock.release() def T2_job():
global A,lock
lock.acquire() for i in xrange(10):
A += 10
print 'T2_job',A lock.release() if __name__ == "__main__":
lock = threading.Lock()
A = 0 #全局变量
thread1 = threading.Thread(target = T1_job) #添加线程
thread2 = threading.Thread(target = T2_job) thread1.start() #执行添加的线程
thread2.start() thread1.join()
thread2.join()
全局解释器锁ＧＩＬ（Global Interpreter Lock）
GIL并不是Python的特性，他是CPython引入的概念，是一个全局排他锁。
解释执行python代码时，会限制线程对共享资源的访问，直到解释器遇到I/O操作或者操作次数达到一定数目时才会释放GIL。
所以，虽然CPython的线程库直接封装了系统的原生线程，但CPython整体作为一个进程，同一时间只会有一个获得GIL的线程在跑，其他线程则处于等待状态。这就造成了即使在多核CPU中，多线程也只是做着分时切换而已，所以多线程比较适合IO密集型，不太适合CPU密集型的任务。
同一时刻一个解释进程只有一行bytecode 在执行
#python中 多线程的效率不一定就是 3 个线程就 三倍的效率
#在python中有GIL，线程锁，保证只有一个线程在计算，在不停的切换
#所以 如果是不同的任务，任务之间差别很大，线程之间可以分工合作，可以提高效率，如一个发送消息，另一个接收消息。
#如果处理一大堆的数据，多线程帮不上，需要mutliprocessing 因为每个核有单独的逻辑空间，互相不影响
import time
import threading
from Queue import Queue
def job(l,q):
q.put(sum(l)) def normal(l):
print sum(l) def multithreading(l):
q = Queue()
threads = []
for i in range(3):
t = threading.Thread(target = job,args = (l,q),name = 'T{}'.format(i))
t.start()
threads.append(t)
[t.join() for t in threads]
total = 0
for _ in range(3):
total += q.get()
print total if __name__ == '__main__':
l = list(xrange(1000000))
s_t = time.time()
normal(l*3)
print 'normal time:',time.time()-s_t
s_t = time.time()
multithreading(l)
print 'multithreading time:',time.time() -s_t 1499998500000
normal time: 0.297999858856
1499998500000
multithreading time: 0.25200009346
多进程
multiprocessing库弥补了thread库因为GIL而低效的缺陷。完整的复制了一套thread所提供的接口方便迁移，唯一的不同就是他使用了多进程而不是多线程。每个进程都有自己独立的GIL。但是在windows下多进程的开销要比多线程要大好多，Linux下是差不多的。多进程更加稳定，
multiprocessing Process类代表一个进程对象。
import multiprocessing as mp
import threading as td
import time def job(q):
res = 0
for i in range(100000):
res += i + i **2
q.put(res) def normal():
res = 0
for i in range(100000):
res += i + i **2
print 'normal:',res def multithread():
q = mp.Queue() #这里用多进程的queue没问题的
t1 = td.Thread(target = job,args = (q,))
# t2 = td.Thread(target = job(q,))
t1.start()
# t2.start()
t1.join()
# t2.join()
res1 = q.get()
# res2 = q.get()
print 'thread:',res1 def multiprocess():
q = mp.Queue()
p1 = mp.Process(target = job,args = (q,))
# p2 = mp.Process(target = job(q,))
p1.start()
# p2.start()
p1.join()
# p2.join()
res1 = q.get()
# res2 = q.get()
print 'multiprocess:',res1 if __name__ == '__main__':
st = time.time()
normal()
st1 = time.time()
print 'normal time:',st1 - st
multithread()
st2 = time.time()
print 'thread:',st2 - st1
multiprocess()
print 'process:',time.time() - st2
#进程池 ,Pool中是有return的
import multiprocessing as mp
def job(x):
return x**2 def multiprocess():
pool = mp.Pool() #默认是有几个核就用几个，可以自己设置processes = ？
res = pool.map(job,range(10)) #可以放入可迭代对象，自动分配进程
print res res = pool.apply_async(job,(2,)) #一次只能在一个进程里计算，要达到map的效果，要迭代
print res.get() multi_res = [pool.apply_async(job,(i,)) for i in range(10)] #迭代器
print ([res.get() for res in multi_res])
if __name__ == '__main__':
multiprocess()
#多进程中的global的全局变量 分给不同的cpu，难以交流
#使用 shared memory 进行交流
import multiprocessing as mp value = mp.Value('d',1) #d就是double，i是一个signed int
array = mp.Array('i',[1,3,4]) #只是个一维的而已 ，和numpy的不一样
#锁
import multiprocessing as mp
import time def job(v,num,l):
l.acquire()
for i in range(10):
time.sleep(0.1)
v.value += num
print v.value
l.release() def multiprocess():
v = mp.Value('i',0) #共享内存
l = mp.Lock()
q = mp.Queue()
p1 = mp.Process(target = job,args = (v,1,l))
p2 = mp.Process(target = job,args = (v,3,l))
p1.start()
p2.start()
p1.join()
p2.join() if __name__ == '__main__':
multiprocess()
fork操作：调用一次，返回两次。操作系统自动把当前进程复制一份，分布在父进程和子进程中返回，子进程永远返回0，父进程永远返回子进程的ID。子进程getppid()就可以拿到父进程的ID ,getpid()可以获得当前进程的ID。