Day28：并发编程之多线程

一、什么是线程

　　 - 在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程。

　　- 线程顾名思义，可以把它当做一条流水线工作的过程，进程可以当成一个车间的工作过程，

　　  一个进程车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线，流水线的工作需要电源， cpu就相当于电源。

　　- 进程只是用来把资源集中到一起（进程是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

　　- 多线程的概念是在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。

二、线程的创建开销小

　　- 创建线程的开销要远小于创建进程；如果我们的软件是一个工厂，该工厂有多条流水线，流水线工作需要电源，电源只有一个即cpu（单核cpu）

　　　一个车间就是一个进程，一个车间至少一条流水线（一个进程至少一个线程）创建一个进程，就是创建一个车间

　　　（申请空间，在该空间内建至少一条流水线）而建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小。

　　- 进程之间是竞争关系，线程之间是协作关系。不同的进程争抢电脑相关的资源，例如网速，内存；同一个进程之间的线程是协作关系。

三、线程与进程的区别

　　1、一个进程创建的线程会分享进程创建的地址空间，每个进程拥有自己的地址空间。

　　2、线程可以直接访问其进程的数据段，而进程有自己父进程的数据段的副本。

　　3、线程可以与进程的其他线程直接通信，进程必须使用IPC（进程间通信）来与同级进程通信。　

　　4、新线程很容易创建，而新进程需要复制父进程。

　　5、线程对同一进程下的线程有很大的控制权，而进程只能对子进程进行控制。

　　6、对主线程的更改（取消，变更优先级等）可能会影响进程下的其他线程，而对进程的修改不会影响其子进程

四、为何要用多线程

　　- 多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：

　　　　1. 多线程共享一个进程的地址空间

      　　 2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用

      　　 3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

      　　 4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）

五、threading模块

　　1、开启线程的两种方式

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.start()
    print('主线程')

 

from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('egon')
    t.start()
    print('主线程')

 六、守护线程

　　- 无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁

　　  需要强调的是：运行完毕并不代表运行终止了

　　　　1、对主进程来说，运行完毕指的是主进程代码运行完毕

　　　　2、对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

　　详细解释

　　　　1、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束。

　　　　2、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，

　　　　　  进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

七、同步锁

　　- 两个需要注意的点

　　　　1、线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，

　　　　　  但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来

　　　　2、join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，

　　　　　  join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

　　- GIL和Lock

　　　　1、锁的目的是为了保护共享的数据，让同一时间只能有一个线程来修改共享的数据，所以，为了保护不同的数据，就需要加不同的锁

　　　　2、GIL和Lock是两把锁，保护的数据不一样，前者是解释器级别的（保护的是解释器级别的数据，比如垃圾回收的数据），后者是保护用户

　　　　　  自己开发的应用程序数据，当用户想要保护自己的数据时，就用Lock

　　- 过程分析

　　　　所有线程抢的是GIL锁，或者说所有线程抢的是执行权限

　　　　线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，

　　　　有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，

　　　　有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果

八、死锁与递归锁

　　- 死锁是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

　　此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

'''
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
然后就卡住，死锁了
'''

　　- 解决方法

　　　　使用递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

　　　　这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次acquire。

　　　　直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，
这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止