python多线程和GIL全局解释器锁

1、线程

    线程被称为轻量级进程，是最小执行单元，系统调度的单位。线程切换需要的资源一般，效率一般。 

2、多线程

        在单个程序中同时运行多个线程完成不同的工作，称为多线程

3、并发：

    操作系统同时执行几个程序，这几个程序都由一个cpu处理，但在一个时刻点上只有一个程序在cpu上处理

4、并行：

    操作系统同时执行2个程序，但是有两个cpu，每个cpu处理一个程序，叫并行

5、串行： 

    是指的我们从事某项工作是一个步骤一个步骤去实施 

 

一、多线程

#python3是假的多线程，它不是真真正正的并行，其实就是串行，只不过利用了cpu上下文的切换而已

mport threading
import time
# def test1():
#     for i in range(10):
#         time.sleep(1)             #睡1s
#         print('test1=========>%s' % i)
#
#
# def test2():
#     for i in range(10):
#         time.sleep(1)
#         print('test2=========>%s' % i)
#
# t1 = threading.Thread(target=test1)    #定义一个线程  target=函数名
# t2 = threading.Thread(target=test2)
# t1.start()        #开启线程
# t2.start()
# test1()
# test2()

# 多线程是无序的，并发的

因为在启动一个线程时，线程不会立即执行，而是等待cpu的资源调度。

# def test1(n):
#     time.sleep(1)
#     print('task', n)
# for i in range(10):
#     t = threading.Thread(target=test1,args=('t-%s' % i,))  #args= 后接输出结果  末尾必须加 “ ， ” 号
#     t.start()

 

#计算并发所用的时间

 
# import threading
# import time
# def dest(n):
#     time.sleep(1)
#     print('this is running====>%s' %n)
# l = []     #定义一个空列表
# start = time.time()     #开始的时间
# for i in range(10):        #10个进程
#     t = threading.Thread(target=dest,args=(i,))    
#     t.start()
#     l.append(t)      #把线程执行时间加入到列表
# for g in l:       
#     g.join()            #等待全部线程执行完毕
# end = time.time()            #执行结束时间
# print('time',(end-start))   #执行结束时间 - 开始执行的时间

 

import threading
import time
def test1(n):
    time.sleep(1)
    print('test1====>%s' %n)
def test2(n):
    time.sleep(2)
    print('test2====>%s' %n)
start = time.time()
l = []
t1 =  threading.Thread(target=test1,args=(1,))
t2 = threading.Thread(target=test2,args=(2,))
t1.start()
t2.start()
l.append(t1)
l.append(t2)
for i in l:
    i.join()
end = time.time()
print('time',(end - start))

 

#多线程共享全局变量

# g_num = 0
# def update():
#     global g_num    #global声明全局变量
#     for i in range(10):
#         g_num += 1
#
# def reader():
#     global g_num
#     print(g_num)
#
# t1 = threading.Thread(target=update)
# t2 = threading.Thread(target=reader)
# t1.start()
# t2.start()
 

二、GIL全局解释器锁

        只有获得GIL锁的线程才能真正在cpu上运行。所以，多线程在python中只能交替执行，即使100个线程跑在100核cpu上，也只能用到1核。

 
# import threading
# global_num = 0
# def test1():
#     global global_num        #global声明全局变量
#     for i in range(1000000):
#         global_num += 1
#     print("test1", global_num,threading.current_thread())
#
# def test2():
#     global global_num
#     for i in range(1000000):
#         global_num += 1
#     print("test2", global_num,threading.current_thread())
# t1 = threading.Thread(target=test1)
# t2 = threading.Thread(target=test2)
# t1.start()
# t2.start()
# print(global_num)

结果说明：每次执行结果都不一样，原因是python从上往下执行，主线程走的快，当主线程走到最后print打印结果的时候，test1 test2的count++还在继续执行，所以第一行打印出来的是它们在执行count++过程中的某一个值，至于test1和test2的值不是100w和200w，因为cpu没有足够的时间去进行count++就释放锁提交了

 

#互斥锁

以上出现的结果是随机的，并非我们想要的，所以要加入互斥锁。

互斥锁：

常用来防止两个进程或线程同一时刻访问相同的共享资源， 如果一个线程锁定了一个互斥量，在它解除锁定之前没有其他线程可以锁定这个互斥量。

import threading
import time
global_num = 0
 
lock = threading.Lock()           #互斥锁
 
def test1():
    global global_num
    lock.acquire()
    for i in range(1000000):
        global_num += 1
    lock.release()
    print("test1", global_num)
 
 
def test2():
    global global_num
    lock.acquire()
    for i in range(1000000):
        global_num += 1
    lock.release()
    print("test2", global_num)
 
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
start_time = time.time()
 
t1.start()
t2.start()
t1.join()
t2.join()
print(global_num)

加上互斥锁之后，test1线程执行完才释放锁提交，让test2线程拿到共享资源继续执行，要想结果是200w，就必须是主线程等子线程执行完之后才执行print。

 

#只要在进行耗时的IO操作的时候，能释放GIL，所以只要在IO密集型的代码里，用多线程就很合适