多任务--线程

布满荆棘的人生 2022-03-22 09:08 330阅读 0赞

## 多任务的概念： ##

什么是多任务呢？简单来说，就是操作系统可以同时运行多个任务。现在cpu的多核已经非常普遍了，单核cpu如何执行并行操作？其实就是每个任务分别执行很短的时间，这样总的看来就相当于是在并行运行。

注意区分并行和并发的概念：

*  并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
 *  并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的

线程的小例子：

1 import time
      2 import threading
      3 
      4 def sing():
      5     for i in range(5):
      6         print('唱歌。。。')
      7         time.sleep(1)
      8 
      9 def dance():
     10     for i in range(5):
     11         print('跳舞。。。')
     12         time.sleep(1)
     13 
     14 def main():      
            # 代码执行过程中都会有一个主线程，主线程就是整个代码的执行流程
            # 下面创建了两个子线程对象，target表示子线程对象所需要执行的位置，线程之间互不干扰，从运行
            # 结果来看就相当于是两个函数一起运行。
            # 线程的执行顺序没有确定的顺序，完全是操作系统随机分配
     15     t1 = threading.Thread(target=sing)
     16     t2 = threading.Thread(target=dance)
     17     t1.start()
     18     t2.start()
     19 
     20 if __name__ == '__main__':
     21     main()

### 查看线程数量 ###

threading.enumerate()函数可以查看当前程序执行过程中线程，会以列表的方式显示。

下面是示例代码：

#coding=utf-8
    import threading
    from time import sleep,ctime
    
    def sing():
        for i in range(3):
            print("正在唱歌...%d"%i)
            sleep(1)
    
    def dance():
        for i in range(3):
            print("正在跳舞...%d"%i)
            sleep(1)
    
    if __name__ == '__main__':
        print('---开始---:%s'%ctime())
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
    
        t1.start()
        t2.start()
    
        while True:
            length = len(threading.enumerate())
            print('当前运行的线程数为：%d'%length)
            if length<=1:
                break
    
            sleep(0.5)

### 线程--注意点 ###

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

# coding=utf-8
    
    import threading
    import time
    
    
    class MyThread(threading.Thread):
        def run(self):
            for i in range(3):
                time.sleep(1)
                print(self.name + str(i))  # name属性中保存的是线程的名字
             
    
    def test():
        t = MyThread()
        t.start()  # 执行run方法，run方法执行完之后整个线程结束
    
    
    if __name__ == '__main__':
        test()

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

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

### 多线程--共享全局变量 ###

线程之间共享全局变量，即主线程和子线程之间共用全局变量。

from threading import Thread
    import time
    
    g_num = 100
    
    def work1():
        global g_num
        for i in range(3):
            g_num += 1
    
        print("----in work1, g_num is %d---"%g_num)
    
    
    def work2():
        global g_num
        print("----in work2, g_num is %d---"%g_num)
    
    
    print("---线程创建之前g_num is %d---"%g_num)
    
    t1 = Thread(target=work1)
    t1.start()
    
    #延时一会，保证t1线程中的事情做完
    time.sleep(1)
    
    t2 = Thread(target=work2)
    t2.start()

也可以把列表当作实参传进去：

from threading import Thread
    import time
    
    def work1(nums):
        nums.append(44)
        print("----in work1---",nums)
    
    
    def work2(nums):
        #延时一会，保证t1线程中的事情做完
        time.sleep(1)
        print("----in work2---",nums)
    
    g_nums = [11,22,33]
    
    # args表示向目标函数中传入的参数
    t1 = Thread(target=work1, args=(g_nums,))
    t1.start()
    
    t2 = Thread(target=work2, args=(g_nums,))
    t2.start()

总结：在一个进程中共享全局变量，很方便在多个线程中共享数据，缺点就是线程对全局变量的修改会导致多线程之间全局变量的混乱。

### 共享全局变量会出现的问题 ###

假设两个线程t1和t2都要对全局变量g\_num(默认是0)进行加1运算，t1和t2都各对g\_num加10次，g\_num的最终的结果应该为20。

但是由于是多线程同时操作，有可能出现下面情况：

1.  在g\_num=0时，t1取得g\_num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得g\_num=0
2.  然后t2对得到的值进行加1并赋给g\_num，使得g\_num=1
3.  然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g\_num。
4.  这样导致虽然t1和t2都对g\_num加1，但结果仍然是g\_num=1

实例代码：

import threading
    import time
    
    g_num = 0
    
    def work1(num):
        global g_num
        for i in range(num):
            g_num += 1
        print("----in work1, g_num is %d---"%g_num)
    
    
    def work2(num):
        global g_num
        for i in range(num):
            g_num += 1
        print("----in work2, g_num is %d---"%g_num)
    
    
    print("---线程创建之前g_num is %d---"%g_num)
    
    t1 = threading.Thread(target=work1, args=(1000000,))
    t1.start()
    
    t2 = threading.Thread(target=work2, args=(1000000,))
    t2.start()
    
    while len(threading.enumerate()) != 1:
        time.sleep(1)
    
    print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

输出结果为：

---线程创建之前g_num is 0---
    ----in work1, g_num is 1088005---
    ----in work2, g_num is 1286202---
    2个线程对同一个全局变量操作之后的最终结果是:1286202

那么这个问题如何解决呢？

下面介绍同步的概念：

### 同步 ###

同步的概念是协调步调按照预定的相关顺序进行。如“你先说，我再说”。

基于上面出现的问题提出一个解决思路：

1.  系统调用t1，然后获取到g\_num的值为0，此时上一把锁，即不允许其他线程操作g\_num
2.  t1对g\_num的值进行+1
3.  t1解锁，此时g\_num的值为1，其他的线程就可以使用g\_num了，而且是g\_num的值不是0而是1
4.  同理其他线程在对g\_num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

### 互斥锁 ###

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

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

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

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

# 创建锁
    mutex = threading.Lock()
    
    # 锁定
    mutex.acquire()
    
    # 释放
    mutex.release()
    
    
    # 注意这个锁之前是没有上锁的，那么acquire就不会堵塞
    # 如果在调用acquire对这个锁上锁之前，它已经被其他线程上了锁，那么acquire就会被堵塞，直到这个锁被解锁为止

下面通过互斥锁解决上述的问题：

import threading
    import time
    
    num = 0
    # 创建锁
    mutex = threading.Lock()
    
    def test1(temp):
        global num
        for i in range(temp):
            # 上锁
            mutex.acquire()
            num += 1
            # 解锁
            mutex.release()
        print('num=%d'%num)
            
            
    def test2(temp):
        global num
        for i in range(temp):
            # 上锁
            mutex.acquire()
            num += 1
            # 释放
            mutex.release()
        print('num=%d'%num)
            
            
    def main():
        t1 = threading.Thread(target=test1, args=(1000000,))
        t2 = threading.Thread(target=test2, args=(1000000,))
        t1.start()
        t2.start()
        
    while True:
        length =len(threading.enumerate())
        if length <= 1:
            time.sleep(1)
            print('结束')
            break
        
        
    if __name__ == '__main__':
        main()

总结：

锁的好处：

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

锁的坏处：

*  阻止了多线程并发运行，实际上运行的相当于是一个单线程，效率就大大下降了
 *  由于可以存在多个锁，不同的线程存在不同的锁，并试图获得对方的锁时，可能会造成死锁

### 死锁 ###

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

示例代码：

#coding=utf-8
    import threading
    import time
    
    class MyThread1(threading.Thread):
        def run(self):
            # 对mutexA上锁
            mutexA.acquire()
    
            # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
            print(self.name+'----do1---up----')
            time.sleep(1)
    
            # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
            mutexB.acquire()
            print(self.name+'----do1---down----')
            mutexB.release()
    
            # 对mutexA解锁
            mutexA.release()
    
    class MyThread2(threading.Thread):
        def run(self):
            # 对mutexB上锁
            mutexB.acquire()
    
            # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
            print(self.name+'----do2---up----')
            time.sleep(1)
    
            # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
            mutexA.acquire()
            print(self.name+'----do2---down----')
            mutexA.release()
    
            # 对mutexB解锁
            mutexB.release()
    
    mutexA = threading.Lock()
    mutexB = threading.Lock()
    
    if __name__ == '__main__':
        t1 = MyThread1()
        t2 = MyThread2()
        t1.start()
        t2.start()

如示例代码，两个进程一起执行，并分别对A、B上锁，然后继续执行到分别对B、A上锁的时候发现AB已经被上锁了，这两个线程分别等待对方释放资源，会造成僵持不下的局面，也就是死锁

避免死锁：

*  程序设计时要尽量避免（银行家算法）
 *  添加超时时间

### 银行家算法（了解） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70][]

### 案例：多任务版UDP聊天器 ###

import socket
    import threading
    
    
    def send_msg(udp_socket):
        """获取键盘数据，并将其发送给对方"""
        while True:
            # 1. 从键盘输入数据
            msg = input("\n请输入要发送的数据:")
            # 2. 输入对方的ip地址
            dest_ip = input("\n请输入对方的ip地址:")
            # 3. 输入对方的port
            dest_port = int(input("\n请输入对方的port:"))
            # 4. 发送数据
            udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))
    
    
    def recv_msg(udp_socket):
        """接收数据并显示"""
        while True:
            # 1. 接收数据
            recv_msg = udp_socket.recvfrom(1024)
            # 2. 解码
            recv_ip = recv_msg[1]
            recv_msg = recv_msg[0].decode("utf-8")
            # 3. 显示接收到的数据
            print(">>>%s:%s" % (str(recv_ip), recv_msg))
    
    
    def main():
        # 1. 创建套接字
        udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        # 2. 绑定本地信息
        udp_socket.bind(("", 7890))
    
        # 3. 创建一个子线程用来接收数据
        t = threading.Thread(target=recv_msg, args=(udp_socket,))
        t.start()
        # 4. 让主线程用来检测键盘数据并且发送
        send_msg(udp_socket)
    
    if __name__ == "__main__":
        main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70]: /images/20220322/6703e6e25bb34e5b9e3c06f3b0617db9.png