• python 多线程


    python 多线程

    import threading
    from time import ctime,sleep
    
    
    def eat(sth):
        for i in range(2):
            print("I am eating %s. %s" %(sth,ctime()))
            sleep(1)
    
    def drink(sth):
        for i in range(2):
            print("I am drinking %s! %s" %(sth,ctime()))
            sleep(5)
    
    threads = []
    t1 = threading.Thread(target=eat,args=('水果',))
    threads.append(t1)
    t2 = threading.Thread(target=drink,args=('啤酒',))
    threads.append(t2)
    # t1.start()
    # t2.start()
    # print("都结束了 %s" %ctime())
    
    if __name__ == '__main__':
        for t in threads:
            t.start()
    
        print("聚餐全部结束了 %s" %ctime())
    
    输出结果:                                                                 
    I am eating 水果. Sat Nov 21 16:43:46 2020
    I am drinking 啤酒! Sat Nov 21 16:43:46 2020
    聚餐全部结束了 Sat Nov 21 16:43:46 2020 I am eating 水果. Sat Nov 21 16:43:47 2020 I am drinking 啤酒! Sat Nov 21 16:43:51 2020 Process finished with exit code 0

    用threading.Thread类来开启多线程

    import threading
    import time
    
    class myThread(threading.Thread):         # 继承父类threading.Thread
       def __init__(self, threadID, name, counter):
          threading.Thread.__init__(self)
          self.threadID = threadID
          self.name = name
          self.counter = counter
    
       # 把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
       def run(self):
          print("Starting " + self.name + '   at: ' + time.ctime(time.time()))
          print_time(self.name, self.counter, 5)
          print("Exiting " + self.name + '   at: ' + time.ctime(time.time()))
    
    
    def print_time(threadName, counter, delay):
       while counter:
          time.sleep(delay)
          print("%s process at: %s" % (threadName, time.ctime(time.time())))
          counter -= 1
    
    
    # 创建新线程
    thread1 = myThread(1, "Thread-1", 10)
    thread2 = myThread(2, "Thread-2", 10)
    
    # 开启线程
    thread1.start()
    thread2.start()
    
    # 等待线程结束
    thread1.join()
    thread2.join()
    
    print("主线程和子线程全部结束。。。。。。。。")
    
    输出结果:
    Starting Thread-1   at: Sat Nov 21 16:55:00 2020
    Starting Thread-2   at: Sat Nov 21 16:55:00 2020
    Thread-2 process at: Sat Nov 21 16:55:05 2020
    Thread-1 process at: Sat Nov 21 16:55:05 2020
    Thread-2 process at: Sat Nov 21 16:55:10 2020
    Thread-1 process at: Sat Nov 21 16:55:10 2020
    Thread-1 process at: Sat Nov 21 16:55:15 2020
    Thread-2 process at: Sat Nov 21 16:55:15 2020
    Thread-2 process at: Sat Nov 21 16:55:20 2020
    Thread-1 process at: Sat Nov 21 16:55:20 2020
    Thread-2 process at: Sat Nov 21 16:55:25 2020
    Thread-1 process at: Sat Nov 21 16:55:25 2020
    Thread-2 process at: Sat Nov 21 16:55:30 2020
    Thread-1 process at: Sat Nov 21 16:55:30 2020
    Thread-1 process at: Sat Nov 21 16:55:35 2020
    Thread-2 process at: Sat Nov 21 16:55:35 2020
    Thread-1 process at: Sat Nov 21 16:55:40 2020
    Thread-2 process at: Sat Nov 21 16:55:40 2020
    Thread-2 process at: Sat Nov 21 16:55:45 2020
    Thread-1 process at: Sat Nov 21 16:55:45 2020
    Thread-1 process at: Sat Nov 21 16:55:50 2020
    Exiting Thread-1   at: Sat Nov 21 16:55:50 2020
    Thread-2 process at: Sat Nov 21 16:55:50 2020
    Exiting Thread-2   at: Sat Nov 21 16:55:50 2020
    主线程和子线程全部结束。。。。。。。。
    
    Process finished with exit code 0

    不带锁的多线程共享资源

    def work():
        global n
        print('开始执行work方法')
        # lock.acquire()
        # print('已经获取线程的锁资源')
        temp=n
        # time.sleep(5)
        n=temp-1
        print('n : ' + str(n))
        # lock.release()
        print('work方法执行结束。。。。。。')
    if __name__ == '__main__':
        # lock=Lock()
        n=10
        for i in range(10):
            p=Thread(target=work)
            p.start()
    
    输出结果:  #----------------下面的结果是瞬间输出的,基本上没有先后顺序---------------------
    开始执行work方法
    n : 9
    work方法执行结束。。。。。。
    开始执行work方法
    n : 8
    work方法执行结束。。。。。。
    开始执行work方法
    n : 7
    work方法执行结束。。。。。。
    开始执行work方法
    n : 6
    work方法执行结束。。。。。。
    开始执行work方法
    n : 5
    work方法执行结束。。。。。。
    开始执行work方法
    n : 4
    work方法执行结束。。。。。。
    开始执行work方法
    n : 3
    work方法执行结束。。。。。。
    开始执行work方法
    n : 2
    work方法执行结束。。。。。。
    开始执行work方法
    n : 1
    work方法执行结束。。。。。。
    开始执行work方法
    n : 0
    work方法执行结束。。。。。。
    
    Process finished with exit code 0

    简单的锁机制

    from threading import Thread,Lock
    import os,time
    def work():
        global n
        print('开始执行work方法')
        lock.acquire()
        print('已经获取线程的锁资源')
        temp=n
        time.sleep(5)
        n=temp-1
        print('n : ' + str(n))
        lock.release()
        print('work方法执行结束,已经释放线程的锁')
    if __name__ == '__main__':
        lock=Lock()
        n=10
        for i in range(10):
            p=Thread(target=work)
            p.start()
    
    输出结果:
    开始执行work方法
    已经获取线程的锁资源
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法      #--------------5秒之后开始输出下一行-----------------
    n : 9
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 8
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 7
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 6
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 5
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 4
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 3
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 2
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 1
    work方法执行结束,已经释放线程的锁
    已经获取线程的锁资源      #--------------5秒之后开始输出下一行-----------------
    n : 0
    work方法执行结束,已经释放线程的锁
    
    Process finished with exit code 0
    def work():
        global n
        print('开始执行work方法')
        # lock.acquire()
        # print('已经获取线程的锁资源')
        temp=n
        time.sleep(5)
        n=temp-1
        print('n : ' + str(n))
        # lock.release()
        print('work方法执行结束。。。。。。')
    if __name__ == '__main__':
        # lock=Lock()
        n=10
        for i in range(10):
            p=Thread(target=work)
            p.start()
    
    输出结果:
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法
    开始执行work方法      #---------------下面的结果是等5秒之后瞬间输出的,基本上没有先后顺序------------------
    n : 9
    work方法执行结束。。。。。。
    n : 9
    n : 9
    work方法执行结束。。。。。。n : 9work方法执行结束。。。。。。
    n : 9
    work方法执行结束。。。。。。
    
    
    work方法执行结束。。。。。。
    n : 9
    work方法执行结束。。。。。。
    n : 9
    work方法执行结束。。。。。。
    n : 9n : 9
    work方法执行结束。。。。。。
    
    n : 9
    work方法执行结束。。。。。。
    work方法执行结束。。。。。。
    
    Process finished with exit code 0
  • 相关阅读:
    北斗对时设备(GPS校时产品)在数字城市系统中的应用
    京准电子,北斗授时产品取代GPS对时设备服务各行业
    北斗校时系统(GPS授时设备)几种时间同步方法
    网络对时服务器(NTP校时服务器)应用港口信息化系统
    关于医院NTP授时服务器(NTP校时服务器)部署工作
    变电站里NTP校时器(gps网络时间服务器)产品的应用
    C++学习(二十九)(C语言部分)之 顺序表
    C++学习(二十八)(C语言部分)之 文件操作
    C++学习(二十七)(C语言部分)之 预处理命令
    C++学习(二十六)(C语言部分)之 结构体3(联合,枚举)
  • 原文地址:https://www.cnblogs.com/111testing/p/14016356.html
Copyright © 2020-2023  润新知