线程 ，进程和协程

Posted 2020-09-18 叶祖辉

一、线程（目的提高执行效率）

计算机中执行任务的最小单元

优点：共享内存，IO操作的时候，创造并发操作

缺点：抢占资源

二、进程（提高执行效率）

进程就是一个程序在一个数据集上的一次动态执行过程

优点：同时利用多个CPU，能够同时进行多个操作

缺点：消耗资源（重新开辟内存空间）

三、线程和进程的关系

　　线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与 属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和 栈)。 

1、进程不是越多越好，CPU个数 == 进程个数最好

2、线程也不是越多越好，具体案例具体分析，（请求上下文切换耗时）

IO密集型（不用CPU）

　　多线程

计算密集型（用CPU）

　　多进程

3、全局解释器锁

# import threading
# import time
# def f1(num):
#     time.sleep(1)
#     print(">>>%s"%num)
#     return
# for i in range(10):
#     t = threading.Thread(target=f1,args=(i,),name="t.%d"%i) #创造线程
#     t.start()
# print(a)
#当不用线程的时候，就是单线程，每生成一个数CPU获取一个，按顺序输出用线程的时候，先创建多个线程，每个线程负责生成一个数，因为生成线程的速度大于生成数的速度，CPU随机获取生成的数，然后一并输出，而且顺序不同

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令

更多方法：

　　t.start() : 激活线程，

　　t.getName() : 获取线程的名称

　　t.setName() ： 设置线程的名称 

　　t.name() : 获取或设置线程的名称

　　t.is_alive() ： 判断线程是否为激活状态

　　t.isAlive() ：判断线程是否为激活状态

　　t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程， 主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执 行完毕后，等待前台线程也执行完成后，程序停止

　　t.isDaemon() ： 判断是否为守护线程

　　t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。

　　t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

　　t.run() ：线程被cpu调度后自动执行线程对象的run方法

线程锁

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了

多线程共享同一内存地址的资源，而多进程不共享

import threading
import time
globals_num = 0
lock = threading.RLock()
def Func():
    lock.acquire()  # 获得锁
    global globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release()  # 释放锁
for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

 如果我们要确保balance计算正确，就要给change_it()上一把锁，当某个线程开始执行change_it()时，我们说，该线程因为获得了锁，因此其他线程不能同时执行change_it()，只能等待，直到锁被释放后，获得该锁以后才能改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。创建一个锁就是通过threading.RLock()来实现

线程锁threading.RLock和threading.Lock

我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐

 threading.Event

Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

• Event.wait([timeout]) ： 堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
• Event.set() ：将标识位设为Ture
• Event.clear() ： 将标识伴设为False。
• Event.isSet() ：判断标识位是否为Ture。

import threading
 
def do(event):
    print(\'start\')
    event.wait()
    print(\'execute\')
 
event_obj = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()
 
event_obj.clear()
inp = input(\'input:\')
if inp == \'true\':
    event_obj.set()

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。

queue模块