Python 多线程

一、线程的使用

需导入模块： from threading import Thread

二、基本使用

 def fun1(arg1, v):
     print(arg1)

 print('before')
 t1 = Thread(target=fun1, args=('aaa',11,))
 t1.start()
 print('此线程名称：', t1.getName())

 t2 = Thread(target=fun1, args=('bbb',22,))
 t2.start()
 print('此线程名称：', t2.getName())

 print('after')

三、常用方法

• start
• getName()
• setName()
• isDaemon()
• setDaemon()
• join(timeout)
• run()

 def fun2():
     for i in range(100):
         print(i)
         time.sleep(1)

 print('start')
 t1 = Thread(target=fun2)
 print('是否守护线程：', t1.isDaemon())     #默认为False，自动执行
 #设置为守护线程，不自动执行，主程序执行完则子线程不执行，
 #主程序如果没执行完，则子线程随着主程序执行，直至主程序结束，子线程也跟着结束
 t1.setDaemon(True)
 t1.start()
 print('after1')
 print('after2')
 print('after3')
 time.sleep(10)

 def fun1():
     for i in range(10):
         print(i)
         time.sleep(1)

 print('before')
 t1 = Thread(target=fun1)
 t1.start()
 # t1.join()   #主程序执行到join()这里后挺住开始执行子线程，子线程执行结束后主程序继续执行
 t1.join(5)    #最多等5秒，子线程最多执行5秒后主进程继续向下执行，主程序执行结束后，子线程继续执行

 print('after')

四、自定义线程类

 class MyThread(Thread):
     def run(self):
         time.sleep(3)
         print('我是线程')
         Thread.run(self)    #如果不加此句，则不会执行自定义线程中的函数

 def Bar():
     print('bar')

 t1 = MyThread(target=Bar)
 t1.start()
 print('over')

五、自定义线程类应用 -- 生产者消费者模型

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 from queue import Queue
 from threading import Thread
 import time
 import random

 class Producer(Thread):
     def __init__(self, name, queue):
         '''
         生产者初始化
         :param name:生产者名称
         :param queue:容器
         '''
         self.__Name = name
         self.__Queue = queue
         super(Producer, self).__init__()    #调用父类构造方法

     def run(self):
         while True:
             if self.__Queue.full():
                 time.sleep(random.randrange(5))
             else:
                 self.__Queue.put('包子')
                 time.sleep(random.randrange(5))
                 print('%s %s 生产了一个包子' %(self.__Name, time.strftime('%Y-%m-%d %H:%M:%S')))
             # Thread.run(self)

 class Customer(Thread):
     def __init__(self, name, queue):
         '''
         消费者初始化
         :param name:消费者名称
         :param queue: 容器
         '''
         self.__Name = name
         self.__Queue = queue
         super(Customer, self).__init__()

     def run(self):
         while True:
             # print('qsize=',self.__Queue.qsize())
             if self.__Queue.empty():
                 time.sleep(random.randrange(5))
             else:
                 self.__Queue.get_nowait()
                 time.sleep(random.randrange(3))
                 print('%s %s 消费了一个包子，还剩%d个包子' %(self.__Name, time.strftime('%Y-%m-%d %H:%M:%S'), self.__Queue.qsize()))
             # Thread.run(self)

 que = Queue(maxsize=100)

 # print(que.qsize())

 liFu = Producer('李师傅', que)
 liFu.start()

 zhangFu = Producer('张师傅', que)
 zhangFu.start()

 wangFu = Producer('王师傅', que)
 wangFu.start()

 for item in range(20):
     name = '陈涛%d' %(item,)
     temp = Customer(name, que)
     temp.start()

 # print(que.qsize())

 # print(que.qsize())
 # que.put('1')
 # que.put('2')
 # print('empty: ', que.empty())
 # print(que.qsize())
 # que.get()
 # que.get()
 # print('empty: ', que.empty())

六、函数编程实现生产者消费者模型

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 import time
 import threading
 import random
 import queue

 def Producer(name, que):
     while True:
         if que.qsize()<3:
             que.put('包子')
             print('%s 生产了一个包子' % name)
         else:
             print('还有3个包子')
         time.sleep(random.randrange(2))

 def Customer(name, que):
     while True:
         try:
             que.get_nowait()
             print('%s 消费了一个包子' % name)
         except Exception:
             print('没有包子了...')
         time.sleep(random.randrange(3))

 que = queue.Queue(100)

 xf1 = threading.Thread(target=Producer,args=('师傅1',que))
 xf1.start()
 xf2 = threading.Thread(target=Producer,args=('师傅2',que))
 xf2.start()

 xli = threading.Thread(target=Customer,args=('小李',que))
 xli.start()
 xzh = threading.Thread(target=Customer,args=('小张',que))
 xzh.start()

七、线程锁

 #!/usr/bin/evn python
 # -*- coding:utf-8 -*-

 import threading
 import time

 num = 0

 def fun1(n):
     time.sleep(1)
     global num
     lock.acquire()  # 需要锁，会独占CPU的操作，此句应放在对数据操作的时候
     num += 1
     lock.release()  #释放锁，对数据操作完后要把锁释放掉，在没有释放前，不可以再添加需要锁
     # time.sleep(0.01)  如果还有sleep一会，则表示此时不需CPU处理，则下面的print就不会按顺序输出
     print(num)  #如果释放锁后直接print，则是CPU锁定刚结束，还占用着CPU，则会按顺序输出

 lock = threading.Lock() #线程锁

 for i in range(100):
     t = threading.Thread(target=fun1, args=('n',))
     t.start()

八、递归线程锁 #一般不常用

 #!/usr/bin/evn python
 # -*- coding:utf-8 -*-

 import threading
 import time

 num = 0
 num2 = 0

 def fun1(n):
     time.sleep(1)
     global num
     global num2
     lock.acquire()  # 需要锁，会独占CPU的操作，此句应放在对数据操作的时候
     num += 1
     lock.acquire()  #使用递归锁就可以在锁内嵌套锁
     num2 += 1
     lock.release()  #使用递归锁必须要把请求道的锁这个释放
     lock.release()
     print(num, num2)

 lock = threading.RLock() #线程锁

 for i in range(100):
     t = threading.Thread(target=fun1, args=('n',))
     t.start()

九、同时进行多个线程

 #!/usr/bin/evn python
 # -*- coding:utf-8 -*-

 import threading
 import time

 num = 0

 def fun1(n):
     time.sleep(1)
     global num
     samp.acquire()  # 需要锁，会独占CPU的操作，此句应放在对数据操作的时候
     num += 1
     print(num)
     samp.release()  #释放锁，对数据操作完后要把锁释放掉，在没有释放前，不可以再添加需要锁

 # lock = threading.Lock() #线程锁
 samp = threading.BoundedSemaphore(5)    #设置此锁最多同时可以几个进行进行数据修改

 for i in range(200):
     t = threading.Thread(target=fun1, args=('n',))
     t.start()

十、线程间的信息交互

 #/usr/bin/env python
 # -*- coding:utf-8 -*-

 import threading
 import time

 def producer():
     print('收银员等人来买包子')
     event.wait()    #等待消息变化，等待有进程执行set()返回True
     event.clear()   #等到set()变成True了，则恢复set()的状态

     print('收银员：有人来买包子')
     print('收银员：给他做一个包子')
     time.sleep(3)

     print('收银员：给你包子')
     event.set()

 def customer():
     print('张三来买包子')
     event.set()

     time.sleep(1)
     print('张三：等待取包子')

     event.wait()
     event.clear()
     print('张三：谢谢')

 event = threading.Event()   #线程间可以互通消息的变量

 kf = threading.Thread(target=producer)
 kf.start()
 zs = threading.Thread(target=customer)
 zs.start()