python多线程和GIL

总结：1 线程的并发是利用cpu上下文的切换2 线程是最小的调度单位3 python3是假的多线程，它不是真真正正的并行，其实就是串行，   只不过利用了cpu上下文的切换而已4 多线程执行的顺序是无序的5 多线程共享全局变量6 线程是继承在进程里的，没有进程就没有线程7 只要在进行耗时的IO操作的时候，能释放GIL，所以只要在IO密集型的代码里，用多线程就很合适，计算频繁时，不要用多线程多线程执行的顺序是无序的

1. 1. import threading
   2. import time
   4. def test1(n):
   5.     time.sleep(1)
   6.     print('task-%s'%n)
   8. for i in range(10):
   9.     t=threading.Thread(target=test1,args=('%s'%i,))
   10.     t.start()

多线程共享全局变量

1. import threading
2. g_num=0
3. def update():
4.     global g_num
5.     for i in range(10):
6.          g_num+=1
7. def reader():
8.     print(g_num)
9. t1=threading.Thread(target=update)
10. t2=threading.Thread(target=reader)
11. t1.start()
12. t2.start()

线程执行时间

1. import threading
2. import time
3. def test1(n):
4.     time.sleep(1)
5.     print('task-%s'%n)
6. l=[]
7. start=time.time()
8. for i in range(10):
9.     t=threading.Thread(target=test1,args=(i,))
10.     t.start()
11.     l.append(t)
12. for j in l:
13.     j.join()
14. end=time.time()
15. print('cost',(end-start))

GIL全局解释器锁

1. import threading
2. count=0
3. lock=threading.Lock()
4. def test1():
5.     global count
6.     lock.acquire()
7.     for i in range(100000):
8.         count+=1
9.     lock.release()
10. def test2():
11.     global count
12.     lock.acquire()
13.     for i in range(100000):
14.         count+=1
15.     lock.release()
16. t1=threading.Thread(target=test1)
17. t2=threading.Thread(target=test2)
18. t1.start()
19. t2.start()
20. t1.join()
21. t2.join()
22. print(count)

为了解决这个数据不能同步的问题，设计了gil全局解释器锁同一时间只能有一个线程使用共享数据，其它线程处于等待状态。GIL使得解释器同一时间只能运行一个线程