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