线程和队列

进程：一段程序的执行过程 是最小的资源单位

线程：微进程，是最小的执行单元

一个程序至少有一个进程，一个进程至少有一个线程（主线程）

多线程的简单实现：

import threading
import time
def play():
    print('star play game %s'%time.ctime())
    time.sleep(3)
    print('end play game %s' % time.ctime())

def read():
    print('star read book %s' % time.ctime())
    time.sleep(5)
    print('end read book %s' % time.ctime())


if __name__=='__main__':
    t1=threading.Thread(target=play)
    t1.start()

    t2=threading.Thread(target=read)
    t2.setDaemon(True) #守护线程 与主线程同步结束 主线程只会考虑t1是否执行完成
    t2.start()

    # t2.join()#必须等他执行完才可以执行

    print('the end...')

 用Event 来处理线程同步下某个线程优先被执行 其他线程处于等待之下：

import threading
import time
class MyThread(threading.Thread):
    def run(self):
        pass
class Boss(threading.Thread):
    def run(self):
        print('现在开始加班哈')
        event.set()
        time.sleep(5)
        print('ok,现在可以下班了哈')
        event.set()

class Worker(threading.Thread):
    def run(self):
        event.wait()  #等待老板讲话
        print('我靠,一言不合就加班')
        time.sleep(2)
        event.clear() #清除第一次的event
        event.wait() #二次等待老板发话
        print('快走，下班咯！！！')
        # event.clear()


if __name__=='__main__':
    event=threading.Event()  #创建一个线程同步对象

    l=[]
    for i in range(4):
        l.append(Worker())
    l.append(Boss())

    for t in l:
        t.start()

    for t in l:
        t.join()

    print('the end...')

线程同步锁的启用：threading.Lock

import threading
import time


def sun():
   global n

   lock.acquire()  #启用
   temp=n
   time.sleep(0.001)
   n=temp+1
   lock.release()   #释放

n=0
lock=threading.Lock() #一个同步锁对象
lis=[]
for i in range(100):
    t=threading.Thread(target=sun)
    t.start()
    lis.append(t)

for k in lis:
    k.join()

print(n)

 信号量 Semaphore() 同时可以开几个进程 不填参数则默认为1个

import time
import threading
class MyThread(threading.Thread):
    def run(self):
        pass

class Show(threading.Thread):
    def run(self):
       if sen.acquire():
            print(self.name)
            time.sleep(2)
            sen.release()

if __name__=='__main__':
    sen=threading.Semaphore(5)   #一次可以同时进来五个
    lis=[]
    for i in range(20):
        lis.append(Show())

    for t in lis:
        t.start()
    for t in lis:
        t.join()

    print('the end。。。')

 队列queue：一种新的数据结构用来解决线程安全问题

import queue
q=queue.Queue(5)        #先进先出
q=queue.LifoQueue(5)    #先进后出
q=queue.PriorityQueue(5) #按优先级输出 序号小的先输出 数值必须放在列表里面

q.put([2,'kevin'])
q.put([1,23])
q.put([4,['a','b','c']])
q.put([3,{'name':'jim'}])

while True:
    print(q.get()[1])
    print('***********')

 生产者消费者模式：通过一个容器来取消二者的强耦合性 用队列来使二者达到平衡关系

import threading
import queue
import time
q=queue.Queue()

def Scz(name): #生产者
    count=0
    while count<10:
        print('making ……')
        time.sleep(2)
        q.put(count)

        print('%s做好了第%s个包子'%(name,count))
        count += 1
        q.task_done()
        print('ok')

def Xfz(name):#消费者
    count=0
    while count<10:
        time.sleep(5)
        print('waitting……')
        q.join()
        data=q.get()
        # q.join()
        print('%s吃了第%s个包子'%(name,data))
        count+=1

s=threading.Thread(target=Scz,args=('厨师',)) 
x1=threading.Thread(target=Xfz,args=('消费者1',))  #args必须为元组接收参数
x2=threading.Thread(target=Xfz,args=('消费者2',))
x3=threading.Thread(target=Xfz,args=('消费者3',))

s.start()
x1.start()
x2.start()
x3.start()