python线程GIL

python线程的GIL问题（全局解释器锁）
什么是GIL：由于python的解释器设计中加入解释器锁，导致了python解释器，导致python的解释器同一时刻只能执行一个线程，大大降低了程序的执行效率。
进程和线程的区别联系
1.两者都是多任务的编程的方式，都能使用计算机的多核资源
2.进程的创建删除消耗的计算机资源比较多
3.进程空间数据互不干扰，线程使用全局变量通信。
4.一个进程可以有多个分支线程，两者是包含关系
5.多个线程共享资源，在共享资源操作时往往需要同步互拆处理
6.进程线程在系统中都有自己的特有的属性标志，如ID,代码段，命令集等
线程和进程的理解
进程的运行特征：
1.可以使用计算机的多核资源
2.进程是计算机分配资源的最小单位
3.进程之间的运行互不影响，各自独立
4.每个进程拥有独立的空间，各自使用自己空间资源
线程的运行特征：
1.一个进程中可以包含多个线程
2.线程也是一个运行行为，消耗计算机资源
3.一个进程中的所有线程共享这个进程的资源
4.多个线程之间的运行互不影响各自运行
5.线程的创建和销毁资源远小于资源
6.各个线程也有自己的ID等特征

import time
def count(x,y):
    c=0

    while c<7000000:
        c+=1
        x+=1
        y+=1
a=time.time()
for i in range(10):
    count(1,1)
b=time.time()
print(b-a)

测试结果：16.24834823608398416

import time
#io密集型
def io():
    write()
    read()
def write():
    f=open("test","w")
    for i in range(1500000):
        f.write("hello world\n")
    f.close()
def read():
    f=open("test")
    lines=f.readlines()
    f.close()
a=time.time()
for i in range(10):
    io()
b=time.time()
print(b-a)

测试结果：15.041374206542969

import time
from threading import Thread
def count(x,y):
    c=0
    while c<7000000:
        c+=1
        x+=1
        y+=1
jobs=[]
a=time.time()
for i in range(10):
    t = Thread(target=count(1,1))
    jobs.append(t)
    t.start()
for i in jobs:
    i.join()
b=time.time()
print(b-a)

测试结果：16.7465341091156

import time
from threading import Thread
#io密集型
def io():
    write()
    read()
def write():
    f=open("test","w")
    for i in range(1500000):
        f.write("hello world\n")
    f.close()
def read():
    f=open("test")
    lines=f.readlines()
    f.close()
jobs=[]
a=time.time()
for i in range(10):
    t=Thread(target=io)
    jobs.append(t)
    t.start()

for i in jobs:
    i.join()

b=time.time()
print(b-a)

测试结果：16.099533081054688

from multiprocessing import Process
import time
def count(x,y):
    c=0
    while c<7000000:
        c+=1
        x+=1
        y+=1
        
jobs=[]
a=time.time()
for i in range(10):
    t=Process(target=count,args=(1,1))
    jobs.append(t)
    t.start()
for i in jobs:
    i.join()

b=time.time()
print(b-a)

测试结果：10.56594181060791

from multiprocessing import Process
import time
def io():
    write()
    read()
def write():
    f=open("test","w")
    for i in range(1500000):
        f.write("hello world\n")
    f.close()
def read():
    f=open("test")
    lines=f.readlines()
    f.close()
jobs=[]
a=time.time()
for i in range(10):
    t=Process(target=io)
    jobs.append(t)
    t.start()

for i in jobs:
    i.join()
b=time.time()
print(b-a)

测试结果：5.332746505737305
上边是测试计算密集型和IO密集型的单线程，多线程，单进程，多进程不同的测试结果，当然电脑不同，测试的结果也不同，pycharm是3.x的版本。这里不难看出在无阻塞的情况下，多线程和单线程程序执行的效率差不多，甚至还不知道单线程效率，但是在多进程运行相同内容却可以有明显的效率提升。