Python基础第十六天（进程，线程）

进程

当程序不运行的时候我们称之为程序，当程序运行起来他就是一个进程；程序只有一个，但进程可以有多个。
进程是系统进行资源分配和调度的基本单位。

from multiprocessing import Process
import time
import os
def sing():
    for i in range(10):
        print("我在唱第{}句歌词".format(i+1))
        time.sleep(1)
def dance():
    for i in range(10):
        print("我在跳第{}段舞蹈".format(i+1))
        time.sleep(1)
if __name__=="__main__":#多进程
    t1=Process(target=sing)
    t2=Process(target=dance)
    t1.start()
    t2.start()
# sing()
# dance()


count=0
def hanshu1():
    global count
    for i in range(1000):
        count+=1
    print("函数1",count)
def hanshu2():
    global count
    for i in range(1000):
        count+=1
    print("函数2",count)
if __name__=='__main__':
    t1=Process(target=hanshu1)
    t2=Process(target=hanshu2)
    t1.start()
    t2.start()
# # hanshu1()
# # hanshu2()


def sing(num):
    print("参数是",num,"进程的ID",os.getpid(),"父进程ID",os.getppid())
def dance(num):
    print("参数是",num,"进程的ID",os.getpid(),"父进程ID",os.getppid())
if __name__=="__main__":#主进程
    print("主进程ID",os.getpid())
    p1=Process(target=sing,args=(9,))#以元组传进去
    p2=Process(target=dance,args=(99,))#创建子进程
    p1.start()
    p2.start()

注：getpid是获得该进程的id，getppid是获得主进程的id


from multiprocessing import Queue,Process
import time

def producer(q):
    for i in range(10):
        bz="包子：%d"%(i+1)
        print("生产"+bz)
        q.put(bz)
        time.sleep(1)
def consumer(q):
    for i in range(10):
        bz=q.get()
        print("消费者"+bz)
if __name__=="__main__":
    q=Queue(3)
    p1=Process(target=producer,args=(q,))
    p2=Process(target=consumer,args=(q,))
    p1.start()
    p2.start()

进程之间的通讯

可以使用Queue队列
put添加
get获取

from multiprocessing import Queue

q=Queue(4)#4代表可以最多存4个
q.put("包子")
q.put("香蕉")
q.put("苹果")
print("执行到这了")
q.put("西瓜")
print("开始吃")

print(q.get())
print(q.get())
print(q.get())
print(q.get())



q=Queue(4)
q.put("包子")
q.put("香蕉")
q.put("苹果")
print(q.qsize())#结果为3
while q.qsize()>0:
    print(q.get())#拿一个q.qsize()就少一个




q=Queue(3)
q.put(10)
q.put(20)
q.put(30)
try:
    q.put(40,block=False)#需要拿走一个才能放；#加一个block=False使得出现异常，不然会一直等待
except:
    print("队满了，没法再装了")
print("到这了")


q=Queue(3)
q.put(10)
q.put(20)
print(q.get())
print(q.get())
try:
    print(q.get(block=False))#加一个block=False使得出现异常，不然会一直等待
except:
    print("没人放东西了")
print("程序走到这了")

进程子类化

from multiprocessing import Process
import os,time
class SubProcess(Process):#进程子类化
    def __init__(self,x):
        super().__init__()
        self.x=x
    def run(self):#重新编写run函数，覆盖父类的run方法。进程启动的时候调用此方法
        for i in range(self.x):
            print("启动进程",i,os.getpid())
            time.sleep(1)
if __name__ == '__main__':
    p=SubProcess(3)
    p.start()#启动进程
    p1=SubProcess(3)
    p1.start()


一个生产一个吃
from multiprocessing import Process,Queue
import os,time
class Producter(Process):
    def __init__(self,q):
        super().__init__()
        self.q=q

    def run(self):
        for i in range(10):
            bz = "包子：%d" % (i + 1)
            print("生产" + bz)
            self.q.put(bz)
            time.sleep(1)

class Consumer(Process):
    def __init__(self, q):
        super().__init__()
        self.q = q
    def run(self):
        for i in range(10):
            bz = self.q.get()
            print("消费者" + bz)
if __name__=="__main__":
    q=Queue(5)
    p1=Producter(q)
    p2=Consumer(q)
    p1.start()
    p2.start()




两个生产30个三个吃30个
from multiprocessing import Process, Queue
import  time
class Pro(Process):
    def __init__(self,q,name):
        super().__init__()
        self.name=name
        self.q=q
    def run(self):
        for i in range(15):
            bz = self.name+"包子：%d" % (i + 1)
            print(bz)
            self.q.put(bz)
            time.sleep(1)
class Con(Process):
    def __init__(self,q,name):
        super().__init__()
        self.name=name
        self.q=q
    def run(self):
        for i in range(10):
            bz = self.q.get()
            print(self.name,"吃", bz)

if __name__ == '__main__':
    q=Queue(5)
    p1=Pro(q,"张三")
    p2=Pro(q,"李四")
    p1.start()
    p2.start()
    # p1.join()
    p3=Con(q,"门")
    p4=Con(q,"曹")
    p5=Con(q,"郭")
    p3.start()
    p4.start()
    p5.start()

注：什么.join()即为该子进程结束后才执行主进程



from multiprocessing import Queue
q=Queue(3)
print(q.empty())#判断是否为空，这里结果True
q.put(1)
q.put(2)
q.put(3)
print(q.full())#判断是否装满，这里结果为True

进程池

from multiprocessing import Pool
import time

def hanshu1(name):
    for i in range(5):
        print(name,i)
        time.sleep(1)
if __name__ == '__main__':
    p=Pool(3)
    a="abcde"
    for x in a:
        p.apply(hanshu1,(x,))#阻塞，同时只跑一个进程
    p.close()



def hanshu1(name):
    for i in range(5):
        print(name,i)
        time.sleep(1)
if __name__ == '__main__':
    p=Pool(4)#进程池
    a="abcde"
    for x in a:
        p.apply_async(hanshu1,(x,))#不阻塞，同时跑多个进程（根据进程池里数是则跑几个,这里是同时跑4个）
    p.close()
    p.join()#阻塞主进程，等待子进程结束




def zuoye(name):
    print(name,"我在写代码")
    time.sleep(1)
    return name+"写完代码了"
def chouyan(status):
    print("去抽烟因为"+status)
if __name__ == '__main__':
    p=Pool(1)
    p.apply_async(zuoye,args=("张三",),callback=chouyan)
    p.close()
    p.join()

#类似于迅雷下载
def downLoad(move):
    for i in range(5):
        print(move,"下载进度%.2f%%"%((i+1)/5*100))
        time.sleep(1)
    return move
def alert(name):
    print(name,"下载完毕，请收看")
if __name__ == '__main__':
     movies=["哪吒",'小青龙','A计划',"亚洲飞鹰"]
     p=Pool(3)
     for move in movies:
         p.apply_async(downLoad,args=(move,),callback=alert)#callback当前面函数执行完后，给后面函数一个返回值，这个返回值就是后面函数传闻进来的参数
     p.close()
     p.join()

线程

1、进程是资源分配的最小单位，线程是CPU调度的最小单位
2、每一个进程至少有一个线程
3、进程里面的线程共享进程所有资源

import time
from threading import Thread
import threading
count=0
def hanshu1():
    global count
    for i in range(10):
        time.sleep(1)
        count+=1
    print("函数1",count)
def hanshu2():
    global count
    for i in range(10):
        time.sleep(1)
        count+=1
    print("函数2",count)
if __name__ == '__main__':
    t1=Thread(target=hanshu1)#因为线程资源共享所以结果是10和20，如果是进程则为10和10
    t2=Thread(target=hanshu2)
    t1.start()
    t1.join()
    t2.start()
    t2.join()


import os
def sing():
    for i in range(10):
        print("唱歌%d"%(i+1),os.getpid())
        time.sleep(1)
def dance():
    for i in range(10):
        print("跳舞%d"%(i+1),os.getpid())
        time.sleep(1)
if __name__ == '__main__':
    t1=Thread(target=sing)
    t2=Thread(target=dance)
    t1.start()
    t2.start()


## setDaemon()
def get(num):
    for i in range(num):
        print(i)
        time.sleep(1)
if __name__ == '__main__':
    t1=Thread(target=get,args=(5,))
    t1.setDaemon(True)#setDaemon()方法将t1变为守护线程，且要放在开始前。就是主线程结束后，守护线程也就结束了，不管是否执行完成。
    t1.start()
    print("主线程结束了")



def sing():
    for i in range(10):
        print("唱歌%d"%(i+1))
        time.sleep(1)
def dance():
    for i in range(10):
        print("跳舞%d"%(i+1))
        time.sleep(1.5)
if __name__ == '__main__':
    t1=Thread(target=sing)
    t2=Thread(target=dance)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("结束")

1、threading.current_thread()返回当前的线程的变量
2、threading.enumerate()返回一个包含正在运行的线程的list（有主线程和多个子线程）
3、threading.active_count()返回正运行的线程数量与（len(threading.enumerate()）结果相同

def sing():
    for i in range(3):
        print("唱歌%d"%(i+1),threading.current_thread())
        time.sleep(1)
def dance():
    for i in range(3):
        print("跳舞%d"%(i+1),threading.current_thread())
        time.sleep(1)
if __name__ == '__main__':
    t1=Thread(target=sing,name="刘德华")
    t2=Thread(target=dance,name="张惠妹")
    t1.start()
    t2.start()
    print(threading.enumerate())
    print(threading.active_count(),len(threading.enumerate()))
    t1.join()
    t2.join()
    print("结束")

线程子类化

import threading,time
from threading import Thread
class T(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        for i in range(10):
            print(self.name,"跳舞%d"%(i+1))
            time.sleep(1)

class S(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        for i in range(10):
            print(self.name,"唱歌%d"%(i+1))
            time.sleep(1)
if __name__ == '__main__':
    t=T("张三")
    t1=S("李四")
    t.start()
    t1.start()

线程之间共享全局变量

进程里面的线程共享进程所有资源

import threading
g_num=0
def hanshu1():
    global g_num
    g_num+=5
def hanshu2():
    print(g_num)
if __name__ == '__main__':
    t1=threading.Thread(target=hanshu1)
    t2=threading.Thread(target=hanshu2)
    t1.start()
    t2.start()



import time
from threading import Thread
import threading
count=0
def hanshu1():
    global count
    for i in range(10):
        time.sleep(1)
        count+=1
    print("函数1",count)
def hanshu2():
    global count
    for i in range(10):
        time.sleep(1)
        count+=1
    print("函数2",count)
if __name__ == '__main__':
    t1=Thread(target=hanshu1)#因为线程资源共享所以结果是10和20，如果是进程则为10和10
    t2=Thread(target=hanshu2)
    t1.start()
    t1.join()
    t2.start()
    t2.join()

正常的结果是100000和200000
但结果不是

import threading
from threading import Thread,Lock
g_num=0
def hs1():
    global g_num
    for i in range(100000):
        g_num+=1
    print(g_num)
def hs2():
    global g_num
    for i in range(100000):
        g_num+=1
    print(g_num)
if __name__ == '__main__':
    t1=threading.Thread(target=hs1)
    t2=threading.Thread(target=hs2)
    t1.start()
    t2.start()



加个互斥锁就是预期结果了
g=0
def hs1():
    global g
    l.acquire()
    for i in range(100000):
        g+=1
    l.release()
    print("函数1",g)

def hs2():
    global g
    l.acquire()
    for i in range(100000):
        g+=1
    l.release()
    print("函数2",g)

if __name__ == '__main__':
    l=Lock()
    t1=Thread(target=hs1)
    t2=Thread(target=hs2)
    t1.start()
    t2.start()