Python多任务-线程

最新推荐文章于 2022-12-01 20:22:14 发布

夕麻

最新推荐文章于 2022-12-01 20:22:14 发布

阅读量302

点赞数 1

分类专栏： python编程技巧文章标签：多线程 thread

本文链接：https://blog.csdn.net/weixin_45735361/article/details/104012488

版权

python编程技巧专栏收录该内容

19 篇文章 0 订阅

订阅专栏

多任务

有很多的场景中的事情是同时进行的，比如开车的时候手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的
在程序中模拟多任务：

import time

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        time.sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        time.sleep(1)


if __name__ == '__main__':
    sing()
    dance()

在运行的上述代码中，其实并不是真正意义的多任务，因为他完成的是先把唱歌唱完了，再跳舞，而不是两个一起完成。
在计算机中的多任务我们可以理解为，同时运行着qq，qq音乐，英雄联盟等。
计算机执行多任务的方式可以分为并行、并发两种：
并行:真的多任务 cpu大于当前执行的任务
并发:假的多任务 cpu小于当前执行的任务
那么我们应该怎么在代码中实现多任务呢？

线程完成多任务

import threading
import time


def sing():
    for i in range(3):
        print("正在唱歌...%d" % i)
        time.sleep(1)


def dance():
    for i in range(3):
        print("正在跳舞...%d" % i)
        time.sleep(1)


def main():
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

使用线程我们导入threading模块，并使用其中的Thread方法创建线程，target为指向。
如果加上：t.setDaemon(True) 为守护线程不会等子线程结束

如果加上t.join()为等待子线程执行结束主线程继续执行

验证子线程的执行与创建

threading.enumerate() 查看当前线程的数量

import time
import threading


def sing():
    for i in range(3):
        print("正在唱歌....%d" % i)
        time.sleep(1)


def dance():
    for i in range(3):
        print("正在跳舞....%d" % i)
        time.sleep(1)


if __name__ == '__main__':
    print(threading.enumerate())
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    print(threading.enumerate())
    t1.start()
    print(threading.enumerate())
    t2.start() 
    print(threading.enumerate())

当调用Thread的时候，不会创建线程。
当调用Thread创建出来的实例对象的start方法的时候，才会创建线程以及开始运行这个线程。
所以四次打印出来的结果会是一个，一个，两个，三个。
主线程会等到子线程执行结果之后主线程才会结束。

继承Thread类创建线程

import threading


class A(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        for i in range(5):
            print(i)


if __name__ == '__main__':
    t = A()
    t.start()

继承Thread类创建线程时需注意的是需要再类里添加run方法，而线程开始执行使用的还是t.start()。

多线程共享全局变量(线程间通信)

import threading
import time

num = 100

def demo1():
    global num
    num += 1
    print("demo1---%d" % num)


def demo2():
    print("demo2---%d" % num)


def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    # time.sleep(1)

    t2.start()
    # time.sleep(1)

    print("main---%d" % num)


if __name__ == '__main__':
    main()

三次打印出的结果都是101，可见多线程是共享全局变量的。

多线程参数-args

当多线程需要传入参数时，我们可以通过threading.Thread(target=test, args=(num,))这样的形式来传入参数。

共享全局变量资源竞争

一个线程写入,一个线程读取,没问题,但是如果两个线程都写入呢？

import threading
import time

num = 0


def demo1(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo1---num:%d' % num)


def demo2(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo2--num:%d' % num)


def main():
    t1 = threading.Thread(target=demo1, args=(1000000,))
    t2 = threading.Thread(target=demo2, args=(1000000,))

    t1.start()
    t2.start()
    print("main----num:%d" % num)


if __name__ == '__main__':
    main()

如这种情况我们会发现打印出来的结果并不准确。
这时我们可以使用互斥锁：
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

import threading
import time

num = 0
# 创建一个互斥锁,默认是没有上锁的
mutex = threading.Lock()


def demo1(nums):
    global num
    # 加锁
    mutex.acquire()
    for i in range(nums):
        num += 1
    # 解锁
    mutex.release()
    print('demo1---num:%d' % num)


def demo2(nums):
    global num
    # 加锁
    mutex.acquire()
    for i in range(nums):
        num += 1
    # 解锁
    mutex.release()
    print('demo2--num:%d' % num)


def main():
    t1 = threading.Thread(target=demo1, args=(100000,))
    t2 = threading.Thread(target=demo2, args=(100000,))

    t1.start()
    t2.start()

    time.sleep(2)
    print("main----num:%d" % num)


if __name__ == '__main__':
    main()

如果使用的是RLock，则为可重入的锁。
再现在start后还需加入一个time.sleep的原因为数据过大的话，还需给他一点时间缓一下，不然线程还没执行完，就执行到打印部分了。

死锁

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

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()

遇到这种情况，程序便会堵塞无法继续。
为了避免死锁：
程序设计时要尽量避免
添加超时时间等。

线程同步

当我们需要解决
天猫精灵:天猫精灵你好呀
小爱同学:你好呀
天猫精灵:今天天气怎么样了啊
小爱同学：还可以哟
这样一个功能时，我们会发现仅用到锁是不够的，这时我们应该使用threading中的条件变量同步Condition

import threading


class Xiaoai(threading.Thread):
    def __init__(self, cond):
        super().__init__()
        self.cond = cond


    def run(self):
        self.cond.acquire()
        print("小爱同学：天猫精灵你好呀")
        self.cond.notify()
        self.cond.wait()
        print("小爱同学：今天天气怎么样了啊")
        self.cond.notify()

        self.cond.release()


class Tianmao(threading.Thread):
    def __init__(self, cond):
        super().__init__()
        self.cond = cond

    def run(self):
        self.cond.acquire()
        self.cond.wait()
        print("天猫精灵：你好呀")
        self.cond.notify()
        self.cond.wait()
        print("天猫精灵：还可以哟")

        self.cond.release()


def main():
    cond = threading.Condition()
    xiaoai = Xiaoai(cond)
    tianmao = Tianmao(cond)

    tianmao.start()
    xiaoai.start()


if __name__ == '__main__':
    main()

Condition中使用到的wait()和notify()方法的意思可以理解为是沉睡，唤醒，当需要这个线程先停止运行另一边线程时便是这边的先wait()沉睡了，再notify()唤醒另一边的。
值得注意的是类的__init__方法中必须添加super().__init__()这样对父级__init__方法的描述，不然就会出现raise RuntimeError(“thread.init() not called”)的报错。

多线程的udp聊天器

实现这个功能就是将线程与socket相结合，大致思路为：
1 创建套接字
2 绑定本地信息
3 获取对方IP和端口
4 发送、接收数据
5 创建两个线程，去执行功能

import socket
import threading


def recv_msg(udp_socket):
    """发送数据"""
    while True:
        recv_data = udp_socket.recvfrom(1024)
        print(recv_data)


def send_msg(udp_socket, dest_ip, dest_port):
    """接收数据"""
    while True:
        send_data = input("输入要发送的数据:")
        udp_socket.sendto(send_data.encode('gbk'), (dest_ip, dest_port))


def main():
    """完成udp聊天器"""
    # 创建套接字
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    # 绑定
    udp_socket.bind(("", 8080))

    # 获取对方的IP和端口
    dest_ip = input('请输入对方的IP:')
    dest_port = int(input('请输入对方的port:'))

    t_recv = threading.Thread(target=recv_msg, args=(udp_socket,))
    t_send = threading.Thread(target=send_msg, args=(udp_socket, dest_ip, dest_port))

    t_recv.start()
    t_send.start()


if __name__ == '__main__':
    main()

夕麻

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python多任务-线程

多任务有很多的场景中的事情是同时进行的，比如开车的时候手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的在程序中模拟多任务：import timedef sing(): for i in range(3): print("正在唱歌...%d"%i) time.sleep(1)def dance(): for i in range(3)...
复制链接

扫一扫