【017】Python全栈日记-线程

一、进程与线程

1、功能

进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ

线程，能够完成多任务，比如 一个QQ中的多个聊天窗口

 

2、定义的不同

进程是系统进行资源分配和调度的一个独立单位.

 

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

 

3、区别

一个程序至少有一个进程,一个进程至少有一个线程.

 

线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。

 

进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率

 

线程不能够独立执行，必须依存在进程中

 

4、优缺点

线程和进程在使用上各有优缺点：

线程执行开销小，但不利于资源的管理和保护；而进程正相反。

 

二、多线程

看个例子：

显然，文件下载是串行操作（即，文件0，文件1.。。）

为了提高效率，我们可以使用多线程来下载文件：

多任务可以由多进程完成，也可以由一个进程内的多线程完成。

我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。

由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持。

 

1、threading模块

Python的标准库提供threading模块

启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行：

运行结果：

说明

1. 可以明显看出使用了多线程并发的操作，花费时间要短很多
2. 创建好的线程，需要调用start()方法来启动

 

3.      

运行结果：

注意：至少得有一个主线程，也就是线程数至少为1

 

三、threading注意事项

1. 线程执行代码的封装

通过上面，能够看出，通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法。

示例如下：

运行结果：

说明

·         python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

 

3、线程的执行顺序

说明

从代码和执行结果我们可以看出，多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

所以：

1.     每个线程一定会有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。

2.     当线程的run()方法结束时该线程完成。

3.     无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

4.     线程的几种状态

 

四、多线程-共享全局变量

直接上代码：

运行结果：

列表当做实参传递到线程中

运行结果：

总结：

l  在一个进程内的所有线程共享全局变量，能够在不适用其他方式的前提下完成多线程之间的数据共享（这点要比多进程要好）

l  缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）

 

练习：

新建一个下载任务列表、一个任务完成列表，分别一个下载线程，完成下载任务。其中要显示下载进度，当所有下载任务都完成后，显示“下载完成！”提示。

运行结果：

 

五、同步的概念

1. 多线程开发可能遇到的问题

假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。

但是由于是多线程访问，有可能出现下面情况：

在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

 

问题产生的原因就是没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

 

2. 什么是同步

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

"同"字从字面上容易理解为一起动作

其实不是，"同"字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。

 

3. 解决问题的思路

对于本小节提出的那个计算错误的问题，可以通过线程同步来进行解决

思路，如下:

1.      系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他现在操作num

2.      对num的值进行+1

3.      解锁，此时num的值为1，其他的线程就可以使用num了，而且是num的值不是0而是1

4.      同理其他线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

 

六、互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

 

threading模块中定义了Lock类，可以方便的处理锁定：

其中，锁定方法acquire可以有一个blocking参数。

·         如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）

·         如果设定blocking为False，则当前线程不会堵塞

使用互斥锁实现上面的例子的代码如下：

 

 

可以看到，加入互斥锁后，运行结果与预期相符。

 

上锁解锁过程

当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。

每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。

线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

总结

锁的好处：

·         确保了某段关键代码只能由一个线程从头到尾完整地执行

锁的坏处：

·         阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了

·         由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁

 

 

七、死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子：有两个人分别做“西兰花”和“红烧肉”，每个人都需要“铲子”和“锅”之后才能炒菜。

程序如下：

 

运行结果：

看似没问题，这个结果也确定没问题，但不代表程序没问题。如果将上述代码中的休眠时间注释去掉，（这个时间表示使用资源时消耗的时间）那么执行时将会发生死锁。

注释去掉后的运行结果：

 

1、说明

2、. 避免死锁

l  程序设计时要尽量避免（银行家算法）

l  添加超时时间等

 

八、生产者与消费者模式

1. 队列

(1) 特点：先进先出

(2) python2 VS python3：

(3)使用

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么就做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

a.常用操作

 

b.规定队列长度

 

c.队列优先级

 

d.后入先出队列

 

2. 生产者与消费者模式

 定义：

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

 

案例：

厨师做包子和顾客吃包子问题。

这里，厨师相当于生产者，顾客相当于消费者，顾客吃包子，厨师做包子。做一个假设，如果厨师做包子的速度远远比顾客吃包子的速度要快，有这样一种情况，厨师等顾客吃完一个包子后再做下一个包子（这时我们说厨师与顾客的耦合度高，即厨师做包子与顾客吃包子是紧密相连的），这样显然效率会很低，现实情况中也不可能是这样，因为一旦顾客多时，厨师就有可能忙不过来了。

  可以尝试这样解决：不管顾客有没有吃完包子，厨师也继续做包子，但此时是先把包子放在一个包子柜台中，等顾客有需要时再去包子柜台拿包子。如此一来，厨师和顾客的耦合度就变低了，即厨师做包子并不取决于顾客是否把包子吃完，这样的话效率显然就会高多。

 

1：简单的--两个消费者对应一个生产者

 

运行结果：

 

2：复杂的--多对多

 

运行结果：

 

总结说明：

    为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

 

    什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

 

 

九、ThreadLocal

在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。

1. 使用函数传参的方法

但是局部变量也有问题，就是在函数调用的时候，传递起来很麻烦：

每个函数一层一层调用都这么传参数那还得了？用全局变量？也不行，因为每个线程处理不同的Student对象，不能共享。

 

2. 使用全局字典的方法

如果用一个全局dict存放所有的Student对象，然后以thread自身作为key获得线程对应的Student对象如何？

这种方式理论上是可行的，它最大的优点是消除了std对象在每层函数中的传递问题，但是，每个函数获取std的代码有点low。

有没有更简单的方式？

 

3. 使用ThreadLocal的方法

ThreadLocal应运而生，不用查找dict，ThreadLocal帮你自动做这件事：

运行结果：

 

说明

全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。

可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

4. 小结

一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题。