python多线程编程

分手后的思念是犯贱 2021-09-17 07:44 291阅读 0赞

# 多线程编程 #

#### 概念 ####

线程:线程包含在进程中,是一个调度单位

进程与线程区别:

进程的创建: 会复制一份父进程的内存空间,具备独立的地址空间,修改全局变量不会有影响,进程之间沟通困难

线程的创建:线程之间共用一个内存空间,修改全局会有影响,会存在线程安全问题,可以添加互斥锁,线程不能够独立执行，必须依存在进程中

#### 代码: ####

# 导入线程包
    import threading
    def job(v):
        print(f'{v} 今天要上课{threading.current_thread().name}')
    for v in range(10):
        # 创建一个线程
        t = threading.Thread(target=job, args=(v,))
        # 开启线程
        t.start()

#### 线程继承类: ####

import threading
    class Thread1(threading.Thread):
        def __init__(self, name):
            super(Thread1, self).__init__()
            self.name = name
        # 固定的方法
        def run(self):
            print("今天天气好冷", self.name)
    # 创建一个线程
    t = Thread1("libai")
    # 开启线程
    t.start()

修改全局变量

import threading
    num = 0
    def write():
        global num
        num += 1
        print("write", num)
    def read():
        global num
        num += 1
        print("read", num)
    th = threading.Thread(target=write)
    th.start()
    th2 = threading.Thread(target=read)
    th2.start()
    # 结果输出 1 , 2

线程安全问题

产生原因: 时间片轮转时,还没有执行完就已经轮转出去,等到再次轮转回来继续执行,数据已经发生更新

由于多任务调度的随机性，可能出现一个任务在操作，而另外一个任务也在操作，导致每个任务最终访问的效果出现混乱

import threading
    num = 0
    def add1():
        global num
        for v in range(1000000):
            num += 1
        print("add1", num)
    def add2():
        global num
        for v in range(1000000):
            num += 1
        print("add2", num)
    t1 = threading.Thread(target=add1)
    t1.start()
    t2 = threading.Thread(target=add2)
    t2.start()
    # 结果 add1 1309780
    # add2 1690800

线程安全问题的解决:

添加互斥锁:当一个任务获取到以锁定状态的锁时，任务将被放入等待队列，直到这把锁被释放时被唤醒

import threading
    num = 0
    def add1():
        global num
        # 上锁
        lock.acquire()
        for v in range(1000000):
            num += 1
        # 解锁
        lock.release()
        print("add1", num)
    def add2():
        global num
        # 上锁
        lock.acquire()
        for v in range(1000000):
            num += 1
        # 解锁
        lock.release()
        print("add2", num)
    # 创建一个互斥锁
    lock = threading.Lock()
    t1 = threading.Thread(target=add1)
    t1.start()
    t2 = threading.Thread(target=add2)
    t2.start()
    # 结果 add1 1000000
    # add2 2000000

> lock.acquire() : 加互斥锁
> 
> lock.release() : 解锁

#### 死锁问题 ####

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

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。

#coding=utf-8
    import threading
    import time
    
    class MyThread1(threading.Thread):
        def run(self):
            if mutexA.acquire():
                print(self.name+'----do1---up----')
                time.sleep(1)
    
                if mutexB.acquire():
                    print(self.name+'----do1---down----')
                    mutexB.release()
                mutexA.release()
    class MyThread2(threading.Thread):
        def run(self):
            if mutexB.acquire():
                print(self.name+'----do2---up----')
                time.sleep(1)
                # 解决方法: 添加超时时间 blocking=True,timeout=2
                if mutexA.acquire(blocking=True,timeout=2):
                    print(self.name+'----do2---down----')
                    mutexA.release()
                mutexB.release()
    mutexA = threading.Lock()
    mutexB = threading.Lock()
    if __name__ == '__main__':
        t1 = MyThread1()
        t2 = MyThread2()
        t1.start()
        t2.start()

> 解决: 添加超时时间

#### 线程同步 ####

import threading
    import time
    def a():
        while True:
            # 上第一把锁
            if lock1.acquire():
                print("1")
                time.sleep(1)
                # 解第二把锁
                lock2.release()
    def b():
        while True:
            if lock2.acquire():
                print("2")
                time.sleep(1)
                lock3.release()
    def c():
        while True:
            if lock3.acquire():
                print("3")
                time.sleep(1)
                lock1.release()
    # 准备3把锁
    lock1 = threading.Lock()
    lock2 = threading.Lock()
    lock2.acquire()
    lock3 = threading.Lock()
    lock3.acquire()
    t1 = threading.Thread(target=a)
    t2 = threading.Thread(target=b)
    t3 = threading.Thread(target=c)
    t1.start()
    t2.start()
    t3.start()

#### 死锁 ####

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

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子

#coding=utf-8
    import threading
    import time
    
    class MyThread1(threading.Thread):
        def run(self):
            if mutexA.acquire():
                print(self.name+'----do1---up----')
                time.sleep(1)
    
                if mutexB.acquire():
                    print(self.name+'----do1---down----')
                    mutexB.release()
                mutexA.release()
    
    class MyThread2(threading.Thread):
        def run(self):
            if mutexB.acquire():
                print(self.name+'----do2---up----')
                time.sleep(1)
                if mutexA.acquire():
                    print(self.name+'----do2---down----')
                    mutexA.release()
                mutexB.release()
    
    mutexA = threading.Lock()
    mutexB = threading.Lock()
    
    if __name__ == '__main__':
        t1 = MyThread1()
        t2 = MyThread2()
        t1.start()
        t2.start()

> 解决：添加超时时间

##### 补充: #####

进程：独立内存空间 资源分配的单元

线程：共享内存空间 大大减少内存的使用 ,线程不安全 ,它是一个调试单元 ,最后做事情的那个人

一个程序运行至少一个进程，至少一个线程

什么时候使用多进程，什么时候时候使用多线程？

IO密集型：多线程 input output

CPU密集型：多进程

编译型：c go c\#

解释型：python php ruby perl js

全局解释锁 不是PYthon特征 cpython 多线程的时候，为了保证线程本身安全，加了这个全局解释锁，

在同一时间点，只能有一个线程去CPU上执行