python并发编程1

主进程和子进程

运行结果：

一旦进程创建后，进程就由操作系统调度

代码解析：

子进程与父进程

所以主进程的父进程就是pycharm

args传参

一个参数

两个参数

join作用（创建多个线程）：

不一定哪个进程先执行，10个进程的执行顺序不固定

代码延伸：
 

from multiprocessing import Process
import time
import os
def func(filename,content):
   with open(filename,'w') as f:
       f.write(content*10*'*')
if __name__ =='__main__':
    p_list=[]
    for i in range(10):
        p = Process(target=func, args=('info%s'%i,i))
        p_list.append(p)
        p.start()
        # p.join() 如果加有这句，就会变为同步
    [p.join() for p in p_list]  # 之前的所有进程必须在这里执行完毕才能执行下面的代码
    # p0.join()
    # p1.join()
    # p2.join()#即使p2线程已经结束，可以执行此代码，若p0.p1还没有结束，则需要等到他们结束才能执行此代码
    # p3.join()



    print([i for i in os.walk(r'E:\pythoncode\网络编程\day6-并发编程')])

# 同步 0.1*500 = 50
# 异步 500 0.1  =0.1
# 多进程写文件
# 首先往文件中写文件
# 向用户展示写入文件之后文件夹中所有的文件名

开启多个进程（写文件）：

from multiprocessing import Process
import time
import os
def func(filename,content):
   with open(filename,'w') as f:
       f.write(content*10*'*')
if __name__ =='__main__':
    p_list=[]
    for i in range(10):
        p = Process(target=func, args=('info%s'%i,i))
        p_list.append(p)
        p.start()
        # p.join() 如果加有这句，就会变为同步
    [p.join() for p in p_list]  # 之前的所有进程必须在这里执行完毕才能执行下面的代码
    print([i for i in os.walk(r'E:\pythoncode\网络编程\day6-并发编程')])

# 同步 0.1*500 = 50
# 异步 500 0.1  =0.1
# 多进程写文件
# 首先往文件中写文件
# 向用户展示写入文件之后文件夹中所有的文件名

运行结果：

开启多个线程的第二种方式：

from multiprocessing import Process
import os
# 第一种方式
# p=Process(target=,args)
# p.start()
#第二种
# 自定义类 继承Process类
# 必须实现一个run方法，run方法是在子进程中执行的代码

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()   #继承
        self.arg1=arg1
        self.arg2=arg2
    def run(self):
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)
        print(os.getpid())
    def start(self):
        self.run()
if __name__ =='__main__':
    print('主进程pid：',os.getpid())
    p1=MyProcess(1,2)
    p1.start()
    p2=MyProcess(3,4)
    p2.start()

运行结果：

多进程之间的数据隔离

# 进程与进程之间
from multiprocessing import Process
import os
def func():
    global n  # 声明一个全部变量
    n=0        # 重新定义一个n
    print('pid:%s'%os.getpid(),n)
if __name__ =='__main__':
    n=100
    p=Process(target=func)
    p.start()
    p.join()
    print('主进程：',os.getpid(),n)

运行结果：

对这个数据隔离不太懂

守护进程

#守护进程
#子进程--》守护进程

from multiprocessing import Process
import time
def func():
    while True:
        time.sleep(0.5)
        print('我还活着')

def func2():
    print(' func2 start')
    time.sleep(8)
    print('func2 finished')

if __name__=='__main__':
    p=Process(target=func)
    p.daemon=True
    p.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()  #结束一个子进程
    print(p2.is_alive())
    time.sleep(2)
    print(p2.is_alive())
    i=0
    while i<4:
        print('socketserver')
        time.sleep(1)
        i+=1

# 守护进程会随着 主进程的代码 执行完毕 而 结束

运行结果：

锁机制

from multiprocessing import Process,Lock
import json
import time
def show(i):
    with open('ticket') as f:
        dic=json.load(f)
        print('第%s个人还有%s张票'%(i,dic['ticket']))

def buy_ticket(lock,i):
    lock.acquire()
    with open('ticket') as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic['ticket']>0:
        dic['ticket'] -= 1
        print('\033[32m第%s个人买到票了\033[0m' % i)
    else:
        print('\033[31m第%s个人没有买到票了\033[0m' % i)
    with open('ticket','w') as f:
        json.dump(dic,f)
    lock.release()


if __name__=='__main__':
    for i in range(10):
        p=Process(target=show,args=(i,))
        p.start()
    lock=Lock()
    for i in range(10):
        p = Process(target=buy_ticket, args=(lock,i))
        p.start()

运行结果：

错误案例：

from multiprocessing import Process
def func():
    num=input('>>>')
    print(num)

if __name__ =='__main__':
    Process(target=func).start()

# 发生错误是因为现在这个控制台是主进程的控制台，而输入操作是子线程开启的，所以在主控制台不可以输入，所以报错