线程

作者: GaoYuan117 | 来源:发表于2020-03-06 00:48 被阅读0次
    • python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便的被使用

    1. 使用threading模块

    示例代码:

    import time
    import threading
    
    # 线程共享全局变量
    g_num = 10
    
    g_nums = [1, 2]
    
    
    def sing():
        global g_num
        g_num += 1
        for i in range(5):
            print("唱歌~")
            time.sleep(1)
    
    
    def dance(temp):
        temp.append(21)
        for i in range(5):
            print("跳舞~")
            time.sleep(1)
    
    
    # 创建子线程,方法不要带()
    # target指定调用哪个线程
    # args 指定调用函数的时候传递什么参数过去,只有一个参数的时候也要(g_nums,)
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance, args=(g_nums,))
    
    # 启动线程
    # 线程的运行没有先后顺序
    t1.start()
    t2.start()
    
    print(g_num)
    print(g_nums)
    
    # 查看线程个数
    print(threading.enumerate())
    

    总结

    1. 当调用start()时,才会真正的创建线程,并且开始执行
    2. 主线程会等待所有的子线程结束后才结束
    3. 查看线程个数使用threading.enumerate()

    2. 线程执行代码的封装

    通过使用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)
                msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
                print(msg)
    
    if __name__ == '__main__':
        t = MyThread()
        t.start()
    
    

    总结

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

    3. 线程的执行顺序

    #coding=utf-8
    import threading
    import time
    
    class MyThread(threading.Thread):
        def run(self):
            for i in range(3):
                time.sleep(1)
                msg = "I'm "+self.name+' @ '+str(i)
                print(msg)
    def test():
        for i in range(5):
            t = MyThread()
            t.start()
    if __name__ == '__main__':
        test()
    
    

    执行结果:(运行的结果可能不一样,但是大体是一致的)

        I'm Thread-1 @ 0
        I'm Thread-2 @ 0
        I'm Thread-5 @ 0
        I'm Thread-3 @ 0
        I'm Thread-4 @ 0
        I'm Thread-3 @ 1
        I'm Thread-4 @ 1
        I'm Thread-5 @ 1
        I'm Thread-1 @ 1
        I'm Thread-2 @ 1
        I'm Thread-4 @ 2
        I'm Thread-5 @ 2
        I'm Thread-2 @ 2
        I'm Thread-1 @ 2
        I'm Thread-3 @ 2
    
    

    总结

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

    4. 多线程-共享全局变量

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

    运行结果:

    ---线程创建之前g_num is 100---
    ----in work1, g_num is 103---
    ----in work2, g_num is 103---
    
    

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

    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]
    
    t1 = Thread(target=work1, args=(g_nums,))
    t1.start()
    
    t2 = Thread(target=work2, args=(g_nums,))
    t2.start()
    
    

    运行结果:

    ----in work1--- [11, 22, 33, 44]
    ----in work2--- [11, 22, 33, 44]
    
    

    总结:

    • 优点,在一个进程内的所有线程共享全局变量,很方便在多个线程间共享数据
    • 缺点,线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱(即线程非安全)

    5. 互斥锁

    • 原因:当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制,否则会出现数据错误

    • 作用:某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源

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

    # 创建锁
    mutex = threading.Lock()
    
    # 锁定
    mutex.acquire()
    
    # 释放
    mutex.release()
    
    

    注意:

    • 如果这个锁之前是没有上锁的,那么acquire不会堵塞
    • 如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁,那么此时acquire会堵塞,直到这个锁被解锁为止
    import threading
    import time
    
    g_num = 0
    
    def test1(num):
        global g_num
        for i in range(num):
            mutex.acquire()  # 上锁
            g_num += 1
            mutex.release()  # 解锁
    
        print("---test1---g_num=%d"%g_num)
    
    def test2(num):
        global g_num
        for i in range(num):
            mutex.acquire()  # 上锁
            g_num += 1
            mutex.release()  # 解锁
    
        print("---test2---g_num=%d"%g_num)
    
    # 创建一个互斥锁
    # 默认是未上锁的状态
    mutex = threading.Lock()
    
    # 创建2个线程,让他们各自对g_num加1000000次
    p1 = threading.Thread(target=test1, args=(1000000,))
    p1.start()
    
    p2 = threading.Thread(target=test2, args=(1000000,))
    p2.start()
    
    # 等待计算完成
    while len(threading.enumerate()) != 1:
        time.sleep(1)
    
    print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
    
    

    运行结果:

    ---test1---g_num=1909909
    ---test2---g_num=2000000
    2个线程对同一个全局变量操作之后的最终结果是:2000000
    
    

    可以看到最后的结果,加入互斥锁后,其结果与预期相符。

    总结

    • 确保了某段关键代码只能由一个线程从头到尾完整地执行
    • 阻止了多线程并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了
    • 由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁

    6. 多任务版udp聊天器

    客户端1:

    # -*- coding:utf-8 -*-
    # Author GaoYuan
    
    import socket
    import threading
    
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    udp_socket.bind(("192.168.1.118", 8891))
    
    
    def send_data():
        """发送数据"""
        while True:
            content = input()
            udp_socket.sendto(content.encode("utf-8"), ("192.168.1.118", 8892))
    
    
    def recv_data():
        """接收数据"""
        while True:
            recv_data = udp_socket.recvfrom(1024)
            print(recv_data)
    
    
    threading.Thread(target=send_data).start()
    threading.Thread(target=recv_data).start()
    

    客户端2:

    # -*- coding:utf-8 -*-
    # Author GaoYuan
    
    import socket
    import threading
    
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    udp_socket.bind(("", 8892))
    
    
    def send_data():
        """发送数据"""
        while True:
            content = input()
            udp_socket.sendto(content.encode("utf-8"), ("192.168.1.118", 8891))
    
    
    def recv_data():
        """接收数据"""
        while True:
            recv_data = udp_socket.recvfrom(1024)
            print(recv_data)
    
    
    threading.Thread(target=send_data).start()
    threading.Thread(target=recv_data).start()
    

    相关文章

      网友评论

          本文标题:线程

          本文链接:https://www.haomeiwen.com/subject/srrjrhtx.html