zoukankan      html  css  js  c++  java
  • 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
  • 相关阅读:
    fastjson基本使用 (待继续完善)【原】
    webkit内核浏览器的CSS写法
    sencha touch pull-refresh-panel 面板下拉刷新
    一个非常棒的星星评分插件
    JavaScript字符转Unicode,顺便说句:GitHub的Oh no页面很亮
    Git版本控制软件结合GitHub从入门到精通常用命令学习手册
    手把手教你如何加入到github的开源世界!
    前端面试题:高效地随机选取数组中的元素
    CSS3 动画animation
    CSS3 Transform
  • 原文地址:https://www.cnblogs.com/111testing/p/14016356.html
Copyright © 2011-2022 走看看