python第五十一天----线程,Event,队列

进程与线程的区别:

线程==指令集，进程==资源集  （线程集）

1、同一个进程中的线程共享内存空间,进程与进程之间是独立的

2、同一个进程中的线程是可以直接通讯交流的，进程与间通讯必需通过一个中间的代理才能实现

3、创建线程简单，创建进程，是克隆父进程 

4、一个线程可以控制和操作同一进程里的其他线程，但进程只能操作子进程

5、线程启动速度快，进程启动速度比较慢

线程示例：

import time ,threading

def run(attr):
    print('输出:',attr)
    time.sleep(3)


t1=threading.Thread(target=run,args=('第一个线程',))
t2=threading.Thread(target=run,args=('第二个线程',))

t1.start()#启动线程1
t2.start()#启动线程2

def run2(attr):
    print('输出:',attr)
    time.sleep(3)

run2('第一个线程')
run2('第二个线程')
#以上转为串联执行

继承线程 类写线程

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

import threading,time

class thre(threading.Thread):#继承线程中的类
    def __init__(self,n,times):
        super(thre,self).__init__()
        self.n=n
        self.teims=times
    def run(self):
        print('执行第一线程:',self.n)
        time.sleep(self.teims)

star_time=time.time()
t1=thre('第一线程',3)
t2=thre('第二线程',4)
t1.start()
t2.start()
t1.join()#join等待该线程执行完成

t2.join()
den_time=time.time()-star_time
print(den_time)

等待线程执行完成，用.join

import time ,threading
lock=threading.Lock()#定义一个线程锁变量
def run(attr):
    lock.acquire()#申请一个线程锁
    global num
    print('输出:',attr)
    #time.sleep(3)
    num+=1
    lock.release()#释放线程锁
    time.sleep(3)
    print('输出完成'.center(10,'〓'))
star_time=time.time()#开始时间

num=0
re_lilst=[]#定义一个列表
for i in range(50):
    t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
    #t1.setDaemon(True)#设置为守护进程 当主线程完成,守护也停止
    t1.start()#起动线程
    re_lilst.append(t1)#不用JOIN,避免阻塞为串行

print(threading.current_thread(),threading.active_count())#查看线程 的主 子  活跃线程
    #print('分线程'.center(40,'☆'))
print('数字:',num)
for i in re_lilst:#等待线程 完成
    i.join()
print('数字:',num)
print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())

den_time=time.time()-star_time#总共时间
print(den_time)

守护进程，相当于主进程的下属，当主进程结束，无论守护进程内的是否执行完成，都会停止！

import time ,threading
lock=threading.Lock()#定义一个线程锁变量
def run(attr):
    lock.acquire()#申请一个线程锁
    global num
    print('输出:',attr)

    #time.sleep(3)
    num+=1
    lock.release()#释放线程锁
    time.sleep(3)
    print('输出完成'.center(10,'〓'))

star_time=time.time()#开始时间

num=0
re_lilst=[]#定义一个列表
for i in range(50):
    t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
    t1.setDaemon(True)#设置为守护进程 当主线程完成,守护也停止
    t1.start()#起动线程
    re_lilst.append(t1)#不用JOIN,避免阻塞为串行

print(threading.current_thread(),threading.active_count())#查看线程 的主 子  活跃线程
    #print('分线程'.center(40,'☆'))
print('数字:',num)
# for i in re_lilst:#等待线程 完成
#    i.join()
print('数字:',num)
print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())

den_time=time.time()-star_time#总共时间
print(den_time)

线程锁，在py3中可以不使用：

lock=threading.Lock()

lock.acquire()

递归锁  用于递归线程

import time ,threading

def run(i):
    print('输出:-------',i)
    lock.acquire()#申请锁
    global num1
    num1+=1
    time.sleep(0.1)
    lock.release()#释放锁
    return num1

def run2(i):
    lock.acquire()#申请锁
    global num2
    print('输出:22',i)
    num2+=1
    time.sleep(0.1)
    lock.release()#释放锁
    return num2

def run3(i):
    lock.acquire()#申请锁
    res=run(i)
    print('输出:333',i)
    res2=run2(i)
    time.sleep(0.1)
    print(res,res2)
    lock.release()#释放锁


if __name__ == '__main__':
    star_time=time.time()#开始时间
    num1,num2=0,0
    #lock=threading.Lock()#定义一个线程锁,如是线程锁,递归时会出错
    lock=threading.RLock()#定义一个递归锁

    for i in range(10):
        #t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
        t1=threading.Thread(target=run3,args=(('第%s线程'%i),))#新建线程
        t1.start()#起动线程

    else:
        print('活跃线程数:',threading.active_count())#查看线程 活跃线程数


while threading.active_count()!=1:#不只一个线程,就是说,判断是否是剩下主线程
    #print(threading.active_count())#查看线程 活跃线程数
    pass
else:
    print('主线程:pid,活跃线程数'.center(60,'◇'),threading.current_thread(),threading.active_count())#
    den_time=time.time()-star_time#总共时间
    print(den_time)
    print(num1,num2)

信号量  相当与 多个线程锁 

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

#！usr/bin/env python
#-*-coding:utf-8-*-
# Author calmyan
import time ,threading

def run(attr):
    semaphore.acquire()#申请信号量线程锁
    global num
    print('输出:',attr)
    time.sleep(1)
    semaphore.release()#释放信号量线程锁

star_time=time.time()#开始时间
if __name__ == '__main__':

    semaphore=threading.BoundedSemaphore(4)#信号量 最多允许几个线程同时运行(多把锁)
    for i in range(50):
        t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
        t1.start()#起动线程

while threading.active_count()!=1:#不只一个线程,就是说,判断是否是剩下主线程
    pass
else:
    print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())
    den_time=time.time()-star_time#总共时间
    print(den_time)

Event 线程标志

红绿灯示例

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

import threading,time

event=threading.Event()#生成一个标示位对象
def lighter():#
    count=0 #定义时间秒数
    event.set()#设置标志位
    while True:
        if count>9 and count<15:#设定为红灯
            event.clear()#清除标志位,
            print('33[41;1m变为红灯!33[0m')
        elif count>=15 and count<18 :#为黄灯

            print('33[43;1m变为黄灯!33[0m')
        elif count>=18:
            event.set()#设置标志位
            print('33[42;1m变为绿灯!33[0m')
            count=0#重新计时
        else:
            print('33[42;1m绿灯中.....!33[0m')
        time.sleep(1)
        count+=1#每一秒钟加一次


def car(name):
    while True:
        if event.is_set():#如果有标志 说明为绿灯
            print('[%s]在行驶中....'%name)
            time.sleep(1)
        else:
            print('[%s]在等待中.....'%name)
            event.wait()#等待获取标志
            print('绿灯亮了,[%s]继续行驶...'%name)
            time.sleep(1)


light=threading.Thread(target=lighter,)#定义一个线程
light.start()#启动线程

car1=threading.Thread(target=car,args=('红旗轿车',))#生成一个汽车线程
car1.start()

队列  生产者消费者模型

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

#队列 生产者消费者模型

import threading,time,queue

q=queue.Queue()#创建一个队列

def produ(name):#生产函数
    count=0
    while True:
        bz=name+str(count)
        q.put(bz)
        print('[%s]生产了,第[%s]个[%s]g 包子'%(name,count,bz))
        count+=1
        time.sleep(1.5)

def consump(name):#消费者
    while True:
        i=q.get()#取
        print('[%s]拿到包子[%s],并吃了'%(name,i))
        time.sleep(0.5)


p1=threading.Thread(target=produ,args=('王五包子铺',))#创建一个新线程 生产者
p2=threading.Thread(target=produ,args=('麻子六包子铺',))#创建一个新线程 生产者
r1=threading.Thread(target=consump,args=('张三',))#创建一个新线程 消费者
r2=threading.Thread(target=consump,args=('李四',))#创建一个新线程 消费者
p1.start()
p2.start()
r1.start()
r2.start()