15.python并发编程(线程--进程--协程)

import threading                              #引入线程模块
import time

#从上到下按照主线程执行的
def Hi(num):
    print("hello %d"%num)
    time.sleep(5)                              #模拟时间消耗

if __name__ == ‘__main__‘:
    #创建第一个子线程
    t1=threading.Thread(target=Hi,args=(10,))    #threading.给Thread这个类创建了一个子线程对象t1----target等于要处理的函数名字
    t1.start()                                   #Thread这个类实例出对象t1通过start启动第一个子线程

    #创建第二个子线程
    t2 = threading.Thread(target=Hi, args=(5,))  #threading.给Thread这个类创建了一个子线程对象t2----target等于要处理的函数名字
    t2.start()                                   #Thread这个类实例出对象t2通过start启动第二个子线程

    print("结束..........")                      #主线程

import threading
from time import ctime,sleep
import time

def ListenMusic(name):        #定义函数一

        print ("我是开始 %s. %s" %(name,ctime()))
        sleep(3)
        print("t1结束 %s"%ctime())


def RecordBlog(title):        #定义函数二

        print ("我是开始 %s! %s" %(title,ctime()))
        sleep(5)
        print(‘t2结束 %s‘%ctime())

threads = []                   #定义一个空列表

t1 = threading.Thread(target=ListenMusic,args=(‘t1‘,))    #创建t1把t1加到列表threads里面去
t2 = threading.Thread(target=RecordBlog,args=(‘t2‘,))     #创建t2把t2加到列表threads里面去

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    for t in threads:                                      #对列表执行遍历
        t.start()                                          #把所有线程都开启

    print ("所有都结束 %s" %ctime())                       #主线程

import threading
import time

class MyThread(threading.Thread):

    def __init__(self, num):
        threading.Thread.__init__(self)
        self.num = num

    def run(self):                                  #定义每个线程要运行的函数，必须是run

        print("running on number:%s" % self.num)

        time.sleep(3)

if __name__ == ‘__main__‘:

    t1 = MyThread(1)          #实例类是自己定制的继承threading.Thread，t1就是线程对象
    t2 = MyThread(2)
    t1.start()                #激活run方法
    t2.start()
    print("结束......")       #主线程

import threading
import time

def music():
    print("music开始时间 %s"%time.ctime())
    time.sleep(3)
    print("music结束时间 %s" % time.ctime())

def game():
    print("game开始时间 %s"%time.ctime())
    time.sleep(5)
    print("game结束时间 %s" % time.ctime())

if __name__ == ‘__main__‘:
    #创建第一个子线程
    t1=  threading.Thread(target=music)   #threading.给Thread这个类创建了一个子线程对象t1
    #创建第二个子线程
    t2 = threading.Thread(target=game)    #threading.给Thread这个类创建了一个子线程对象t2

    t1.start()                           #Thread这个类实例出对象t1通过start启动
    t2.start()                           #Thread这个类实例出对象t2通过start启动
    
    #join是t1，t2不执行完主线程不往下执行
    t1.join()
    t2.join()

    #主线程
    print("结束")

import threading
from time import ctime,sleep
import time

def ListenMusic(name):        #定义函数一

        print ("我是开始 %s. %s" %(name,ctime()))
        sleep(3)
        print("t1结束 %s"%ctime())


def RecordBlog(title):       #定义函数二

        print ("我是开始 %s! %s" %(title,ctime()))
        sleep(5)
        print(‘t2结束 %s‘%ctime())

threads = []                 #定义一个空列表

t1 = threading.Thread(target=ListenMusic,args=(‘t1‘,))                #创建t1把t1加到列表threads里面去
t2 = threading.Thread(target=RecordBlog,args=(‘t2‘,))          #创建t2把t2加到列表threads里面去

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    for t in threads:                                                   #对列表执行遍历
        #t.setDaemon(True) #注意:一定在start之前设
        t.start()                                                       #把所有线程都开启

    t.join()                                                            #把t2给join起来
    print ("所有都结束 %s" %ctime())                                      #主线程

import threading
from time import ctime,sleep
import time

def ListenMusic(name):        #定义函数一

        print ("我是开始 %s. %s" %(name,ctime()))
        sleep(3)
        print("t1结束 %s"%ctime())


def RecordBlog(title):       #定义函数二

        print ("我是开始 %s! %s" %(title,ctime()))
        sleep(5)
        print(‘t2结束 %s‘%ctime())

threads = []                 #定义一个空列表

t1 = threading.Thread(target=ListenMusic,args=(‘t1‘,))                #创建t1把t1加到列表threads里面去
t2 = threading.Thread(target=RecordBlog,args=(‘t2‘,))          #创建t2把t2加到列表threads里面去

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    for t in threads:                                                   #对列表执行遍历
        t.start()                                                        #把所有线程都开启
        t.join()                                                         #串行
        
    print ("所有都结束 %s" %ctime())

import threading
from time import ctime,sleep
import time

def xiancheng1(name):        #定义函数一(线程1)

        print ("我是开始 %s %s" %(name,ctime()))
        sleep(3)
        print("t1结束 %s"%ctime())

def xiancheng2(title):       #定义函数二(线程2)

        print ("我是开始 %s %s" %(title,ctime()))
        sleep(5)
        print(‘t2结束 %s‘%ctime())

threads = []                                                  #定义一个空列表

t1 = threading.Thread(target=xiancheng1,args=(‘t1‘,))         #创建线程对象t1
t2 = threading.Thread(target=xiancheng2,args=(‘t2‘,))         #创建线程对象t2

threads.append(t1)                                             #把t1加到列表threads里面
threads.append(t2)                                             #把t2加到列表threads里面

if __name__ == ‘__main__‘:

    for t in threads:                                                   #通过for循环对列表执t.start
        t.setDaemon(True)                                               #把t1和t2都设置成守护线程,子线程守护主线程(一定在start之前设)
        t.start()                                                        #把所有线程都开启

    print ("我是主线程 %s" %ctime())

import threading
from time import ctime,sleep
import time

def xiancheng1(name):        #定义函数一(线程1)

        print ("我是开始 %s %s" %(name,ctime()))
        sleep(3)
        print("t1结束 %s"%ctime())

def xiancheng2(title):       #定义函数二(线程2)

        print ("我是开始 %s %s" %(title,ctime()))
        sleep(5)
        print(‘t2结束 %s‘%ctime())

threads = []                                                  #定义一个空列表

t1 = threading.Thread(target=xiancheng1,args=(‘t1‘,))         #创建线程对象t1
t2 = threading.Thread(target=xiancheng2,args=(‘t2‘,))         #创建线程对象t2

threads.append(t1)                                             #把t1加到列表threads里面
threads.append(t2)                                             #把t2加到列表threads里面

if __name__ == ‘__main__‘:

    for t in threads:                                                   #通过for循环对列表执t.start
        t2.setDaemon(True)                                              #把t2设置成守护线程，t2子线程要守护主线程(一定在start之前设)
        t.start()                                                        #把所有线程都开启

    print ("我是主线程 %s" %ctime())

import threading
from time import ctime,sleep
import time

def ListenMusic(name):        #定义函数一(线程1)

        print ("我是开始 %s. %s" %(name,ctime()))
        sleep(3)
        print("我是结束t1 %s"%ctime())

def RecordBlog(title):       #定义函数二(线程2)

        print ("我是开始 %s! %s" %(title,ctime()))
        sleep(5)
        print(‘我是结束t2 %s‘%ctime())

threads = []                 #定义一个空列表

t1 = threading.Thread(target=ListenMusic,args=(‘t1‘,))         #创建t1把t1加到列表threads里面去
t2 = threading.Thread(target=RecordBlog,args=(‘t2‘,))          #创建t2把t2加到列表threads里面去

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:
    t2.setDaemon(True)                                         #把t1设置成守护线程(一定在start之前设)
    for t in threads:                                          #对列表执行遍历
        t.start()                                               #把所有线程都开启
        print(t.getName())                                      #默认线程名字
        print("count:", threading.active_count())              #修改线程名字

    print ("我是主线程 %s" %ctime())

import threading
from time import ctime,sleep
import time

def ListenMusic(name):        #定义函数一(线程1)

        print ("我是开始 %s. %s" %(name,ctime()))
        sleep(3)
        print("我是结束t1 %s"%ctime())

def RecordBlog(title):       #定义函数二(线程2)

        print ("我是开始 %s! %s" %(title,ctime()))
        sleep(5)
        print(‘我是结束t2 %s‘%ctime())

threads = []                 #定义一个空列表

t1 = threading.Thread(target=ListenMusic,args=(‘t1‘,))         #创建t1把t1加到列表threads里面去
t2 = threading.Thread(target=RecordBlog,args=(‘t2‘,))          #创建t2把t2加到列表threads里面去

threads.append(t1)
threads.append(t2)

if __name__ == ‘__main__‘:

    for t in threads:                                          #对列表执行遍历
        t.setDaemon(True)  # 把t1和t2都设置成守护线程(一定在start之前设)
        t.start()                                               #把所有线程都开启

    while threading.active_count() == 1:                       #表示此时此刻就一个主线程
        print ("我是主线程 %s" %ctime())

import threading
import time
def sub():                            #累减函数sub
    global num                        #在每个线程中都获取这个全局变量

    temp=num                          #把num赋值给temp
    time.sleep(0.001)                 #等待0.001秒
    num=temp-1                        #对此公共变量进行-1操作赋值给num

num=100                               #设定一个共享变量

l=[]                                       #定义空列表

for i in range(100):
    t=threading.Thread(target=sub)         #创建线程执行sub赋值给t
    t.start()                              #执行t
    l.append(t)                            #创建t的时候加到列表l里

for t in l:
    t.join()                              #等着主线程，让主线程在这里不要去执行

print(num)

import threading
import time
def sub():                            #累减函数sub
    global num                        #在每个线程中都获取这个全局变量
    #使用同步锁把这部分改为串行
    lock.acquire()                    #获得一把锁，在锁下面的代码谁都不可以有CPU的切换，只能有一个线程被执行
    temp=num
    time.sleep(0.001)
    num=temp-1                        #对此公共变量进行-1操作赋值给num
    lock.release()                    #释放这把锁，获取锁中间的代码不可以有CPU的切换

num=100                               #设定一个共享变量

l=[]                                       #定义空列表
lock=threading.Lock()                      #创建同步锁lock

for i in range(100):
    t=threading.Thread(target=sub)         #创建线程执行sub赋值给t
    t.start()                              #执行t
    l.append(t)                            #创建t的时候加到列表l里

for t in l:                            #等待所有子线程执行完毕
    t.join()                              

print(num)

import  threading
import time

class MyThread(threading.Thread):               #创建一个类MyThread

    def actionA(self):    #实例方法1
        #五个线程同时抢占
        A.acquire()                               #创建A锁
        print(self.name,"A锁",time.ctime())      #self.name是线程的名字打印A错名字
        time.sleep(2)

        B.acquire()                               #创建B锁
        print(self.name, "B锁", time.ctime())
        time.sleep(1)

        B.release()                               #结束B锁
        A.release()                               #结束A锁

    def actionB(self):     #实例方法2

        B.acquire()                                #创建B锁
        print(self.name, "B锁", time.ctime())
        time.sleep(2)

        A.acquire()                                #创建A锁
        print(self.name, "A锁", time.ctime())
        time.sleep(1)

        A.release()
        B.release()

    def run(self):                   #先执行run方法(开了5分线程同时去执行下面俩函数)
        self.actionA()               #run方法执行actionA()
        self.actionB()               #run方法执行actionB()


if __name__ == ‘__main__‘:         #类的继承方式来启动多线程

    #创建同步锁A
    A=threading.Lock()
    #创建同步锁B
    B=threading.Lock()

    L=[]                        #定义空列表L

    for i in range(5):         #创建5个线程对象同时执行run方法
        t=MyThread()            #继承方式创建线程对象实例自己的类
        t.start()               #执行t
        L.append(t)             #创建t的时候加到列表L里

    for i in L:                #等待所有子线程执行完毕
        i.join()

    print("结束....")

import  threading
import time

class MyThread(threading.Thread):               #创建一个类MyThread

    def actionA(self):    #实例方法1
        #count大于1其它线程是无法进来不会造成死锁
        r_lcok.acquire()                               #acquire一次加一个1  内部count计数器=1
        print(self.name,"A锁",time.ctime())           #self.name是线程的名字打印A错名字
        time.sleep(2)

        r_lcok.acquire()                               #acquire一次加一个1  内部count计数器=2
        print(self.name, "B锁", time.ctime())
        time.sleep(1)

        r_lcok.release()                               #release减一个1   内部count计数器=1
        r_lcok.release()                               #count计数器=0的时候第二个线程就可以再用这把锁

    def actionB(self):     #实例方法2

        r_lcok.acquire()
        print(self.name, "B锁", time.ctime())
        time.sleep(2)

        r_lcok.acquire()
        print(self.name, "A锁", time.ctime())
        time.sleep(1)

        r_lcok.release()
        r_lcok.release()

    def run(self):                   #先执行run方法(开了5分线程同时去执行下面俩函数)
        self.actionA()               #run方法执行actionA()
        self.actionB()               #run方法执行actionB()

if __name__ == ‘__main__‘:         #类的继承方式来启动多线程

    r_lcok = threading.RLock()       #创建递归锁

    L=[]                             #定义空列表L

    for i in range(5):         #创建5个线程对象同时执行run方法
        t=MyThread()            #继承方式创建线程对象实例自己的类
        t.start()               #执行t
        L.append(t)             #创建t的时候加到列表L里

    for i in L:                #等待所有子线程执行完毕
        i.join()

    print("结束....")

import threading,time
class Teacher(threading.Thread):

    def run(self):
        print("Teacher：今天放学都不要走啊。")
        #print(event.isSet())           #打印当前是否被设定event，返回False
        event.set()                     #event.set()设定event，第一个event.wait()以下的代码就可以继续执行
        time.sleep(3)
        print("Teacher：可以下课了。")
        #print(event.isSet())           #打印当前是否被设定event，返回False
        event.set()                     #event.set()设定event

class Student(threading.Thread):
    def run(self):

        event.wait()                     #遇到wait卡住返回到threads.append(Teacher())继续执行。一旦event被设定，等同于pass，下面可以继续执行

        print("Student：命苦啊！")
        time.sleep(1)
        event.clear()                    #event.clear()清空event
        event.wait()                     #遇到wait卡住返回到time.sleep(3)继续执行。一旦event被设定，等同于pass，下面可以继续执行
        print("Student：OhYeah!")

if __name__=="__main__":
    event=threading.Event()              #第一步：创建event对象

    threads=[]                           #第二步：创建列表
    for i in range(3):                  #创建3个Worker线程对象加到列表里
        threads.append(Student())        #Student类继承了threading.Thread，里面有run方法，一旦有这个线程会执行run方法
    threads.append(Teacher())            #第三步：创建一个Teacher对象，也是继承是调用
    for t in threads:                   #第四步：
        t.start()
    for t in threads:                   #第五步：
        t.join()

    print("结束.....")

import threading,time

class myThread(threading.Thread):
    def run(self):

        if semaphore.acquire():     #同时有5个线程进去
            print(self.name)
            time.sleep(3)
            semaphore.release()     #把semaphore释放又可以进来5个线程

if __name__=="__main__":
    semaphore=threading.Semaphore(5)   #semaphore也是锁的一种，threading.Semaphore()创建锁对象，5是每次只能进去5个线程

    thrs=[]                            #空列表
    for i in range(15):               #50线程对象分别去启动执行run方法
        thrs.append(myThread())
    for t in thrs:
        t.start()

import queue              #线程队列

q=queue.Queue(3)          #创建queue对象,3代表最多放3个数据(默认按照先进先出)

q.put(18)                 #将18放入队列中
q.put("hello")            #将hello放入队列中
q.put({"name":"xi"})      #将{"name":"xi"}放入队列中
#q.put(34,False)            #加上参数False参数如果队列满了报错

while 1:                    
    data=q.get()             #通过q.get()将值从队列中取出赋值给data
    #data = q.get(block=False)    #加上参数False参数如果队列满了报错
    print(data)
    print("----------")

import queue              #线程队列

q=queue.LifoQueue(3)            #创建queue对象,3代表最多放3个数据(LifoQueue先进后出)

q.put(12)                   #创建格子放数据12
q.put("hello")             #创建格子放数据hello
q.put({"name":"xi"})      #创建格子放数据{"name":"xi"}

while 1:
    data=q.get()             #通过q.get()取值q的值赋值给data
    print(data)
    print("----------")

import queue              #线程队列

q=queue.PriorityQueue(3)            #创建queue对象,3代表最多放3个数据(PriorityQueue优先级)

q.put([2,12])                   #创建格子放数据12,优先级2
q.put([3,"hello"])             #创建格子放数据hello,优先级3
q.put([1,{"name":"xi"}])       #创建格子放数据{"name":"xi"},优先级1

while 1:
    data=q.get()             #通过q.get()取值q的值赋值给data
    print(data[1])
    print("----------")

import queue              #线程队列

q=queue.Queue(3)          #创建queue对象,3代表最多放3个数据(默认按照先进先出)

q.put(18)                 #将18放入队列中
q.put("hello")           #将hello放入队列中
q.put({"name":"xi"})     #将{"name":"xi"}放入队列中

#q.put_nowait(11)        相当于q.get(False)

print(q.qsize())          #按照具体有多少值来的
print(q.empty())          #是否为空
print(q.full())           #是否是满的

while 1:
    data=q.get()          #通过q.get()将值从队列中取出赋值给data
    print(data)
    print("----------")

import time,random
import queue,threading

q = queue.Queue()                                            #首先创建队列对象q

def Producer(name):                                          #生产者函数Producer
  count = 0                        #生产者定义count = 0
  while count < 5:                #当0小于5的时候
    print("开始生产........")    #执行
    time.sleep(3)
    q.put(count)                    #把当前count的值放到队列q里去
    print(‘生产者 %s 已经生产 %s 号包子..‘ %(name, count))
    count +=1                       #给count加一个1
    q.join()                        #遇到q.join生产者线程等待队列为，开始执行消费者线程，当包子被吃了(队列为空)的时候再往下执行
    print("结束......")

def Consumer(name):                  #消费者函数Consumer
  count = 0
  while count <5:
        time.sleep(random.randrange(4))
        data = q.get()                #q.get()拿到包子
        print("开始吃包子....")
        time.sleep(2)
        q.task_done()                 #俩秒钟后把吃完包子的消息告诉生产者里的q.join()，
        print(‘\033[32;1m消费者 %s 已吃 %s 号包子...\033[0m‘ %(name, data))

        count +=1

p1 = threading.Thread(target=Producer, args=(‘王大厨‘,))    #p1线程作为生产者执行的Producer函数
c1 = threading.Thread(target=Consumer, args=(‘西西‘,))      #c1线程作为消费者执行的Consumer函数
c2 = threading.Thread(target=Consumer, args=(‘一一‘,))      #c2线程作为消费者执行的Consumer函数

#来了3个线程去执行p1,c1,c2
p1.start()
c1.start()
c2.start()

from multiprocessing import Process
import time

def f(name):                                       #定义函数f
    time.sleep(1)
    print(‘hello‘, name,time.ctime())             #1秒钟后打印参数和时间

if __name__ == ‘__main__‘:
    p_list=[]
    for i in range(3):                            #循环创建3个子进程

        p = Process(target=f, args=(‘xixi‘,))     #Process实例化进程对象
        p_list.append(p)                           #加到列表p_list里
        p.start()                                  #启动

    for i in p_list:
        i.join()
    print(‘结束‘)                                 #主进程

from multiprocessing import Process
import time

class MyProcess(Process):

    def run(self):
        time.sleep(1)
        print (‘hello‘, self.name,time.ctime())    #self.name是进程的名字

if __name__ == ‘__main__‘:
    p_list=[]

    for i in range(3):
        p = MyProcess()
        p.start()                 #启动执行def run(self):里的run方法
        p_list.append(p)

    for p in p_list:
        p.join()                  #等待子进程执行完主进程执行

    print(‘结束‘)                 #主进程

from multiprocessing import Process
import time

class MyProcess(Process):

    def run(self):
        time.sleep(1)
        print (‘hello‘, self.name,time.ctime())    #self.name是进程的名字

if __name__ == ‘__main__‘:
    p_list=[]

    for i in range(3):
        p = MyProcess()
        p.daemon=True               #加上守护进程，主进程完了就结束了，不管子进程是否执行完
        p.start()
        p_list.append(p)

    print(‘结束‘)                   #主进程

from multiprocessing import Process
import os
import time

def info(title):                                           #定义函数info
    print("title:", title)
    print(‘当前运行程序父进程的进程号:‘, os.getppid())    
    print(‘当前程序运行的进程号:‘, os.getpid())           

def f(name):                                                #定义函数f,f函数也调用了info
    info(‘function f‘)                                     #调用了info函数
    print(‘hello‘, name)


if __name__ == ‘__main__‘:

    info(‘主进程‘)                             #执行给info传一个字符串

    time.sleep(1)
    print("------------------")
    p = Process(target=info, args=(‘子进程‘,))   #创建一个子进程p
    p.start()                                   #开启
    p.join()