多线程深入解析-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42375099/article/details/94042745

本文详细介绍了多线程的基本概念，包括多线程与多进程的区别，Python中多线程的实现方式，线程的状态，如何使用锁解决数据同步问题，多线程间的通信问题，死锁的产生与解决，以及进程和线程的总结。

文章目录

第三阶段_day15_06/28/19【多线程】

第三阶段_day15_06/28/19【多线程】

1. 多线程简介：

实现多任务：
1.多进程 (CPU计算密集型)
2.多线程(IO密集型)
多任务可以由多进程完成，也可以由一个进程内的多线程完成。我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。Python的标准库提供了两个模块：_thread和threading， thread是低级模块，threading是高级模块，对thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。
全局锁（GIL: Global Interpreter Lock）：多线程有个全局锁，无论CPU和线程数量，一次只能处理一个线程上的任务，所以多线程发挥不出CPU多核的优势。
缺点：发挥不了CPU多核的优势。
优点：有时候需要多核，有时候不需要。输入操作，线程阻塞，切换到另一掉线程工作即可。

2. 多线程的使用：

threading常用方法
- threading.active_count()
- threading.current_thread()
- threading.main_thread()
Thread常用方法
- start()
- run()
- join()：线程中不常用此方法，因为，子线程没完成，主进程是不会结束的
- setName()
- getName()
- is_alive()
- isDaemon()
- setDaemon()
实现-1：必须重写Thread中的run()方法，start()运行的就是Thread的run()方法。

"""
多线程实现多任务方式01：threading.Thread

环境：多线中，有一个全局解释器锁，同一时刻只能有一个线程执行
实际：并发执行
"""
from threading import  Thread
import  time,random

def download1():
    for i in  range(1,101):
        print("{下载任务1进度为：%d%%"%i)
        time.sleep(random.random())

def download2():
    for i in  range(1,101):
        print("{下载任务2进度为：%d%%"%i)
        time.sleep(random.random())


#创建线程对象
t1 = Thread(target=download1)
t2 = Thread(target=download2)
#启动线程
t1.start()
t2.start()

#主进程中写点代码
content = input('请输入内容：')
print(content)
print('主线程执行完毕')

实现-2：

"""
多线程实现多任务方式02：threading.Thread类的子类来实现
注意：重写父类run()方法
"""
import threading
import  time,random
class DownloadThread(threading.Thread):
      def run(self):
          for i in range(1, 101):
              print("{0}下载任务进度为：{1}%%".format(threading.current_thread().getName(),i) )
              time.sleep(random.random())


dt1 = DownloadThread(name='文件1')
dt2 = DownloadThread(name='文件2')

dt1.start()
dt2.start()

print("线程的总数量为：{0}".format(threading.active_count()))
print('主线程为：{0}'.format(threading.main_thread().getName()))

突出多线程的优点：

"""
实现多任务
  1.多进程 (CPU计算密集型)
  2.多线程(IO密集型)

目的：突出多线程的优点
"""
import  threading,multiprocessing,time,random

def method1():
    for i in range(1,101):
        print('下载进度为：{0}'.format(i))
        time.sleep(random.random())


if __name__ == '__main__':
     # 多进程实现多任务; 阻塞了多任务的实现！！！
     # p1 = multiprocessing.Process(target=method1)
     # p1.start()
     # content = input('请输入：') # 程序阻塞在这里！！！
     # print(content)

     # 多线程实现多任务
     th1 = threading.Thread(target=method1)
     th1.start()
     content= input("请输入") # 主线程
     print(content)

3. 线程的状态

出生
- 当用__ new __操作符创建一个线程时。此时程序还没有开始运行线程中的代码
就绪 (针对的是“实现1”)
- 一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程
执行
- 当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法
阻塞：阻塞结束之后，不是进入执行状态，而是进入就绪状态
- 线程运行过程中，可能由于各种原因进入阻塞状态：
  - ①线程通过调用sleep方法进入睡眠状态；
  - ②线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
  - ③线程试图得到一个锁，而该锁正被其他线程持有；
  - ④线程在等待某个触发条件；所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态
死亡
- ①run方法正常退出而自然死亡
- ②一个未捕获的异常终止了run方法而使线程猝死
  
  [外链图片转存失败(img-jKQ586YA-1562145549062)(C:\Users\zhuwe\Desktop\线程死亡.png)]

4. 使用锁lock解决数据同步问题

锁的使用场景：多线程操作，共享数据时，需要注意互斥锁的使用，来保证数据的完整性（正确性）。
所得类型：
1. 互斥锁：Lock
  - 加锁：acquire(block=True, timeout=-1)
  - 解锁：release()
2. 可重入锁：RLock
实例：【火车票】

问题代码01：

"""
问题代码：每次结果都不一样！！！
运行结果：
窗口【1】已售出10万张票，剩余:100000
窗口【2】已售出10万张票，剩余:42621
"""
from threading import Thread

tickets = 200000

def sale1():
    global  tickets
    for i in range(1,100001):
        #模拟售出 一张票
       tickets -=1
    print('窗口【1】已售出10万张票，剩余:{0}'.format(tickets))

def sale2():
    global  tickets
    for i in range(1,100001):
        #模拟售出 一张票
       tickets -=1
    print('窗口【2】已售出10万张票，剩余:{0}'.format(tickets))


#创建两个线程
th1 = Thread(target=sale1)
th2 = Thread(target=sale2)
th1.start()
th2.start()

th1.join()
th2.join()

问题代码02：

"""
解决问题代码：把lock加入到for循环里
运行结果：
窗口【1】已售出10万张票，剩余:100000
窗口【2】已售出10万张票，剩余:0
"""
from threading import Thread, Lock

tickets = 200000
lock = Lock()


def sale1():
    global tickets
    # 加锁
    lock.acquire()
    for i in range(1, 100001):
        # 模拟售出 一张票
        tickets -= 1
    # 释放锁
    lock.release()
    print('窗口【1】已售出10万张票，剩余:{0}'.format(tickets))


def sale2():
    global tickets
    # 加锁
    lock.acquire()
    for i in range(1, 100001):
        # 模拟售出 一张票
        tickets -= 1
    # 释放锁
    lock.release()
    print('窗口【2】已售出10万张票，剩余:{0}'.format(tickets))


# 创建两个线程
th1 = Thread(target=sale1)
th2 = Thread(target=sale2)
th1.start()
th2.start()

th1.join()
th2.join()

最终解决问题代码：

"""
解决问题代码
结果：
窗口【2】已售出10万张票，剩余:19506
窗口【1】已售出10万张票，剩余:0
"""
from threading import Thread,Lock

tickets = 200000
lock = Lock()

def sale1():
    global  tickets

    for i in range(1,100001):
        # 加锁
        lock.acquire()
        #模拟售出 一张票
        tickets -=1
        # 释放锁
        lock.release()

    print('窗口【1】已售出10万张票，剩余:{0}'.format(tickets))

def sale2():
    global  tickets

    for i in range(1,100001):
        # 加锁
        lock.acquire()
        #模拟售出 一张票
        tickets -=1
        # 释放锁
        lock.release()
    print('窗口【2】已售出10万张票，剩余:{0}'.format(tickets))


#创建两个线程
th1 = Thread(target=sale1)
th2 = Thread(target=sale2)
th1.start()
th2.start()

th1.join()
th2.join()

5.多线程间的通信问题：【生产者消费者模式】

Python提供了queue这一线程安全的容器，可以方便的和多线程结合起来。queue包括FIFO先入先出队列 Queue()，LIFO 后入先出队列 LifoQueue()，和优先级队列PriorityQueue()。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。
引入队列，引入线程

"""
多线程间 通信问题( 生产者消费者模式 )
引入队列，引入多线程
步骤：
1. 封装（类）生产者
    循环生产，将产品循环放入队列中
2. 封装（类）消费者
    循环消费，循环从队列中取值
3. 创建线程
4. 启动线程
"""
from queue import Queue
from threading import Thread
import  time

# 创建一个队列：队列最多存储消息是10个
# Queue(): 先进先出
queue = Queue(maxsize=10)

class ProduceThread(Thread):
     # 生产包子个数的计数器
     # 重写父类的构造器要注意：先调用父类的构造器
     count = 0
     def __init__(self,name):
        super(ProduceThread, self).__init__()
        self.name = name

     def run(self):
         while True:
             # 生产了一个包子
             ProduceThread.count+=1
             content ="{0}生产了第{1}个包子".format(self.name,ProduceThread.count)
             print(content)
             # 把生产包子的信息 放入队列中去
             queue.put(content)

class CustomerThread(Thread):
    def __init__(self,name):
        super(CustomerThread, self).__init__()
        self.name=name
    def run(self):
        while True:
            if queue.qsize() >0:
                baozi = queue.get()
                message = "  {0} 吃了{1}".format(self.name,baozi)
                print(message)
            time.sleep(0.4)

p1 = ProduceThread('张三')
c1 = CustomerThread('李四')
c2 = CustomerThread('王五')

p1.start()
c1.start()
c2.start()

6. 死锁

原理：

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源时，就会造成死锁。尽管死锁很少发生，但一旦发生就会造成应用的停止响应

"""
产生死锁情况的程序
"""
import  threading,time

#线程间的共享资源
cLock = threading.Lock()
gLock = threading.Lock()

class XilanhuaThread(threading.Thread):
    def run(self):
         if cLock.acquire(blocking=True):
             print('{0}拿到了铲子'.format(self.name))
             time.sleep(0.1)
             if gLock.acquire():
                print('{0}拿到了锅'.format(self.name))
                gLock.release()
             cLock.release()
             print('{0}炒西兰花操作完毕'.format(self.name))


class HongshaorouThread(threading.Thread):
    def run(self):
        if gLock.acquire(blocking=True):
            print('{0}拿到了锅'.format(self.name))
            time.sleep(0.1)
            if cLock.acquire():
                print('{0}拿到了铲子'.format(self.name))
                cLock.release()
            gLock.release()
            print('{0}炒红烧肉操作完毕'.format(self.name))


x = XilanhuaThread()
h = HongshaorouThread()
x.start()
h.start()

解决方案：

# 方案一：如果锁着，那就算了
 if lock2.acquire(blocking = False)
# 方案二：给你2秒钟时间，把东西给我，不然我就不要了
 if lock2.acquire(timeout=2)

7. 进程和线程总结：

进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所以进程间数据不共享，但是可以通信，开销大。线程：调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在一个进程至少有一个
线程，叫主线程，而多个线程共享内存(数据共享，共享全局变量)，从而极大地提高了程序的运行效率。