1、线程

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

2、多线程

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

3、并发：

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

4、并行：

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

5、串行：

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

一、多线程

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

 1 mport threading

 2 import time

 3 # def test1():

 4 #     for i in range(10):

 5 #         time.sleep(1)             #睡1s

 6 #         print('test1=========>%s' % i)

 7 #

 8 #

 9 # def test2():

10 #     for i in range(10):

11 #         time.sleep(1)

12 #         print('test2=========>%s' % i)

13 #

14 # t1 = threading.Thread(target=test1)    #定义一个线程  target=函数名

15 # t2 = threading.Thread(target=test2)

16 # t1.start()        #开启线程

17 # t2.start()

18 # test1()

19 # test2()

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

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

1 # def test1(n):

2 #     time.sleep(1)

3 #     print('task', n)

4 # for i in range(10):

5 #     t = threading.Thread(target=test1,args=('t-%s' % i,))  #args= 后接输出结果  末尾必须加 “ ， ” 号

6 #     t.start()

#计算并发所用的时间

 1

 2 # import threading

 3 # import time

 4 # def dest(n):

 5 #     time.sleep(1)

 6 #     print('this is running====>%s' %n)

 7 # l = []     #定义一个空列表

 8 # start = time.time()     #开始的时间

 9 # for i in range(10):        #10个进程

10 #     t = threading.Thread(target=dest,args=(i,))

11 #     t.start()

12 #     l.append(t)      #把线程执行时间加入到列表

13 # for g in l:

14 #     g.join()            #等待全部线程执行完毕

15 # end = time.time()            #执行结束时间

16 # print('time',(end-start))   #执行结束时间 - 开始执行的时间

 1 import threading

 2 import time

 3 def test1(n):

 4     time.sleep(1)

 5     print('test1====>%s' %n)

 6 def test2(n):

 7     time.sleep(2)

 8     print('test2====>%s' %n)

 9 start = time.time()

10 l = []

11 t1 =  threading.Thread(target=test1,args=(1,))

12 t2 = threading.Thread(target=test2,args=(2,))

13 t1.start()

14 t2.start()

15 l.append(t1)

16 l.append(t2)

17 for i in l:

18     i.join()

19 end = time.time()

20 print('time',(end - start))

#多线程共享全局变量

 1 # g_num = 0

 2 # def update():

 3 #     global g_num    #global声明全局变量

 4 #     for i in range(10):

 5 #         g_num += 1

 6 #

 7 # def reader():

 8 #     global g_num

 9 #     print(g_num)

10 #

11 # t1 = threading.Thread(target=update)

12 # t2 = threading.Thread(target=reader)

13 # t1.start()

14 # t2.start()

15

二、GIL全局解释器锁

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

 1

 2 # import threading

 3 # global_num = 0

 4 # def test1():

 5 #     global global_num        #global声明全局变量

 6 #     for i in range(1000000):

 7 #         global_num += 1

 8 #     print("test1", global_num,threading.current_thread())

 9 #

10 # def test2():

11 #     global global_num

12 #     for i in range(1000000):

13 #         global_num += 1

14 #     print("test2", global_num,threading.current_thread())

15 # t1 = threading.Thread(target=test1)

16 # t2 = threading.Thread(target=test2)

17 # t1.start()

18 # t2.start()

19 # print(global_num)

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

#互斥锁

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

互斥锁：

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

 1 import threading

 2 import time

 3 global_num = 0

 4

 5 lock = threading.Lock()           #互斥锁

 6

 7 def test1():

 8     global global_num

 9     lock.acquire()

10     for i in range(1000000):

11         global_num += 1

12     lock.release()

13     print("test1", global_num)

14

15

16 def test2():

17     global global_num

18     lock.acquire()

19     for i in range(1000000):

20         global_num += 1

21     lock.release()

22     print("test2", global_num)

23

24 t1 = threading.Thread(target=test1)

25 t2 = threading.Thread(target=test2)

26 start_time = time.time()

27

28 t1.start()

29 t2.start()

30 t1.join()

31 t2.join()

32 print(global_num)

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

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

巴特西

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