python基础知识（二十二）

线程Thread
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。
eg:

from threading import Thread,Lock
import time
dongzuo=0               #全局资源
def sing():
    global dongzuo
    for i in range(5):
        print("唱歌:动作",dongzuo)
        dongzuo+=1         #修改全局资源
        time.sleep(0.6)
def dance():
    global dongzuo    #全局资源
    for i in range(5):
        print("跳舞：动作",dongzuo)
        dongzuo+=1
        time.sleep(0.6)
if __name__ == '__main__':
    t=Thread(target=sing)
    t2=Thread(target=dance)
    t.start()
    t2.start()

结果为：

线程锁
eg：

from threading import Thread,Lock
import time
dongzuo=0               #全局资源
def sing():
    global dongzuo
    for i in range(5):
        lockx.acquire()    #锁获取资源
        print("唱歌:动作",dongzuo)
        dongzuo+=1         #修改全局资源
        lockx.release()    #释放锁
        time.sleep(0.6)
def dance():
    global dongzuo        #全局资源
    for i in range(5):
        lockx.acquire()      #锁获取资源
        print("跳舞：动作",dongzuo)
        dongzuo+=1
        lockx.release()    #释放锁
        time.sleep(0.6)
if __name__ == '__main__':
    lockx=Lock()               #定义一个锁
    t=Thread(target=sing)
    t2=Thread(target=dance)
    t.start()
    t2.start()

结果为：

死锁—>都在等待对方的条件
eg：

from threading import Thread,Lock
import time
def cxxzuoFan():
    guoLock.acquire()     #获取了锅的锁
    print("陈xx获取了锅")
    time.sleep(3)
    shaoLock.acquire()    #希望勺的锁，但是勺的锁被wxxzuoFan首先获得
    print("陈xx可以做饭了")
    shaoLock.release()
    guoLock.release()
def wxxzuoFan():
    shaoLock.acquire()    #获取了勺的锁
    print("王xx获取了勺")
    time.sleep(3)
    guoLock.acquire()     #希望锅的锁，但是锅的锁被cxxzuoFan首先获得
    print("王xx可以做饭了")
    guoLock.release()
    shaoLock.release()
if __name__ == '__main__':
    guoLock=Lock()
    shaoLock=Lock()
    t1=Thread(target=cxxzuoFan)
    t2=Thread(target=wxxzuoFan)
    t1.start()
    t2.start()

结果为：

先进先出的消息队列
eg：

from threading import Thread,Lock
from queue import Queue
q=Queue(3)
print(q.empty())      #判断是否为空
q.put("效益1")
q.put("效益2")
q.put("效益3")
print(q.get())
q.put("效益4")
print(q.full())
try:
    q.put("效益5",block=False)
except:
    print("满了，放不下了")

结果为:

后进先出的消息队列(栈)
eg：

from threading import Thread,Lock
from queue import LifoQueue
q=LifoQueue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

结果为：
3 2 1

优先队列
eg：

from threading import Thread,Lock
from queue import PriorityQueue
q=PriorityQueue(5)
q.put((2,"消息5"))
q.put((1,"消息3"))
q.put((3,"消息2"))
q.put((5,"消息4"))
q.put((4,"消息1"))
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())

结果为:

线程：消费者和生产者
eg:

from threading import Thread
from queue import Queue
import time
def chanbaozi(name,q):
    count=0
    while True:
        bz="包子%d"%(count+1)
        q.put(bz)
        s=name+"生成"+bz
        print(s)
        count+=1
        time.sleep(1)
def chibaozi(name,q):
    while True:
        bz=q.get()
        s=name+"吃"+bz
        print(s)
        time.sleep(1)
if __name__ == '__main__':
    q=Queue(2)
    name="陈"
    t1=Thread(target=chanbaozi,args=(name,q))
    t2=Thread(target=chibaozi,args=("王",q))
    t1.start()
    t2.start()

结果为：

线程子类化
eg：

from threading import Thread
from queue import Queue
import time
class MyThread(Thread):   #继承thread线程类
    def __init__(self,q,style):
        super().__init__()
        self.q=q
        self.style=style
    def run(self):
        if self.style=="生产":
            i = 0
            while i<10:
                self.q.put(str("包子"+str(i+1)))
                s="生产包子"+str(i+1)
                print(s)
                time.sleep(1)
                i=i+1
        else:
            i=0
            while i<10:
                s="消费"+q.get()
                print(s)
                time.sleep(1)
                i=i+1
if __name__ == '__main__':
    q=Queue(3)
    t1=MyThread(q,"生产")
    t2=MyThread(q,"消费")
    t1.start()
    t2.start()

同步互斥锁
eg：

from threading import Thread,Lock
from queue import Queue
import time
x=0
def A():
    global x
    i=0
    l.acquire()
    while i<10000000:
        x=x+1
        i=i+1
    l.release()
    print(x)
def B():
    global x
    l.acquire()
    i=0
    while i<10000000:
        x=x+1
        i=i+1
    l.release()
    print(x)
if __name__ == '__main__':
    l=Lock()
    t1=Thread(target=A)
    t2=Thread(target=B)
    t1.start()
    t2.start()

结果为:

协程
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
eg：

import time
def A(hs):
    i=0
    while i<10:
        print("A开始")
        next(hs)
        print("A结束")
        i=i+1
def b():
    i=0
    while i<10:
        print("B开始")
        yield                 #生成器
        print("B结束")
        i=i+1
if __name__ == '__main__':
    x=b()
    A(x)

结果为: