python：进程 *** 作_python

概述一、多进程应用import socketfrom multiprocessing import Processdef talk(conn):conn.send(b'connected')ret = conn.recv(1024)print(ret)if __name__ == '__main__':sk = socket.socket()sk.bind(('127.0.0.1', 8080))sk.listen()while True:conn,addr = sk.accept()p = Process(target=talk,args=(conn,))p.start()conn.close()sk.close()serverimport socketsk = socket.socket()sk.connect(('127.0.0.1',8080))ret = sk.recv(1024)print(ret)msg = input('>>>')sk.send(msg.encode('utf-8'))sk.close()client二、进程中的其他方法import timefrom multiprocessing import Processdef func():print('--'*10)time.sleep(15)print('--'*10)def cal_time():while True:time.sleep(1)print('过去了1秒')if __name__ == '__main__':p = Process(target=cal_time)p.daemon = True #守护进程：一定在开启进程之前设置p.start()p2 = Process(target=func) # 15sp2.start()for i in range(100): # 10stime.sleep(0.1)print('*'*i)p2.join()1，start()开启一个进程join：用join可以让主进程等待子进程结束1）p.daemon =True #守护进程守护进程会随着主进程的代码执行结束而结束正常的子进程没有执行完的时候主进程要一直等着2）守护进程的作用会随着主进程的代码执行结束而结束,不会等待其他子进程3）注意：守护进程要在start之间设置守护进程中不能再开启子进程2，is_alive与terminateimport timefrom multiprocessing import Processdef func():print('wahaha')time.sleep(5)print('qqxing')if __name__ == '__main__':p = Process(target=func)p.start()print(p.is_alive())time.sleep(0.1)p.terminate()print(p.is_alive())time.sleep(1)print(p.is_alive())p.is_alive() # 是否活着 True代表进程还在 False代表进程不在了p.terminate() # 结束一个进程,但是这个进程不会立刻被杀死def func():print('wahaha')time.sleep(5)print('qqxing')if __name__ == '__main__':p = Process(target=func)p.start()print(p.name,p.pid)p.name = '哇哈哈哈'print(p.name)class MyProcess(Process):def run(self):print('wahaha',self.name,self.pid)time.sleep(5)print('qqxing',self.name,self.pid)if __name__ == '__main__':p = MyProcess()p.start()print(p.pid)# pid 查看这个进程进程id# name 查看这个进程的名字三、锁from multiprocessing import Lock#调用锁lock = Lock() #创建一个锁lock.acquire() # 需要锁拿钥匙lock.acquire() # 需要锁发生阻塞lock.release() # 释放锁还钥匙锁就是在并发编程中保证数据安全import jsonimport timeimport randomfrom multiprocessing import Lockfrom multiprocessing import Processdef search(i):with open('ticket') as f:print(i,json.load(f)['count'])def get(i):with open('ticket') as f:ticket_num = json.load(f)['count']time.sleep(random.random())if ticket_num > 0:with open('ticket','w') as f:json.dump({'count':ticket_num-1},f)print('%s买到票了'%i)else:print('%s没票了'%i)def task(i,lock):search(i) # 查看票lock.acquire()get(i) # 抢票lock.release()if __name__ == '__main__':lock = Lock()for i in range(20): # 20个人同时抢票p = Process(target=task,args=(i,lock))p.start()import jsonimport timeimport randomfrom multiprocessing import Lockfrom multiprocessing import Processdef search(i):with open('ticket') as f:print(i,json.load(f)['count'])def get(i):with open('ticket') as f:ticket_num = json.load(f)['count']time.sleep(random.random())if ticket_num > 0:with open('ticket','w') as f:json.dump({'count':ticket_num-1},f)print('%s买到票了'%i)else:print('%s没票了'%i)def task(i,lock):search(i) # 查看票lock.acquire()get(i) # 抢票lock.release()if __name__ == '__main__':lock = Lock()for i in range(20): # 20个人同时抢票p = Process(target=task,args=(i,lock))p.start()买火车票的程序四、信号量import timeimport randomfrom multiprocessing import Semaphore#调用信号量from multiprocessing import Processdef sing(i,sem):sem.acquire()print('%s : 进入 ktv'%i)time.sleep(random.randint(1,10))print('%s : 出 ktv'%i)sem.release()# 迷你唱吧 20个人，同一时间只能有4个人进去唱歌if __name__ == '__main__':sem = Semaphore(4)for i in range(20):Process(target=sing,args=(i,sem)).start()#信号量的数量就是锁当中钥匙的数量五、事件事件 —— 异步阻塞事件是所有的进程，都陷入阻塞from multiprocessing import Event #调用事件模块# e = Event() # 实例化一个事件标志/类似于交通信号灯# e.set() # 将标志变成非阻塞/类似于交通灯变绿# e.wait() # 刚实例化出来的一个事件对象，默认的信号是阻塞信号/默认是红灯# # 执行到wait，要先看灯，绿灯行红灯停，如果在停的过程中灯绿了，# # 就变成非阻塞了# e.clear() # 将标志又变成阻塞/交通灯变红## e.is_set() # 是否阻塞 True就是绿灯 False就是红灯import timeimport randomfrom multiprocessing import Processfrom multiprocessing import Eventdef traffic_light(e):while True:if e.is_set():time.sleep(3)print('红灯亮')e.clear() # 绿变红else:time.sleep(3)print('绿灯亮')e.set() # 红变绿def car(i,e):e.wait()print('%s车通过'%i)if __name__ == '__main__':e = Event() # 立一个红灯tra = Process(target=traffic_light,args=(e,))tra.start() # 启动一个进程来控制红绿灯for i in range(100):if i%6 == 0 :time.sleep(random.randint(1,3))car_pro = Process(target=car, args=(i,e))car_pro.start()六、队列队列进程之间的通信1.进程之间通信可以使用multiprocessing 的 Queue模块2.队列有两种创建方式第一种不传参数这个队列就没有长度限制；传参数，创建一个有最大长度限制的队列3.提供两个重要方法；put get4.qsize查看队列的大小import timedef producer(q): # 生产者for i in range(100):q.put('包子%s'%i)def consumer(q): # 消费者for i in range(100):time.sleep(1)print(q.get())if __name__ == '__main__':q = Queue(10) # 托盘p = Process(target=producer,args=(q,))p.start()c1 = Process(target=consumer, args=(q,))c2 = Process(

一、多进程应用

multiprocessing def talk(conn):
conn.send(b'connected')
ret = conn.recv(1024)
print(ret)

if name == 'main':
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.Listen()
while True:
conn,addr = sk.accept()
p = Process(target=talk,args=(conn,))
p.start()
conn.close()
sk.close()

=,8080= sk.recv(1024= input(>>

二、进程中的其他方法

multiprocessing (*1015(*10def cal_time():
while True:
time.sleep(1)
print('过去了1秒')

if name == 'main':
p = Process(target=cal_time)
p.daemon = True #守护进程：一定在开启进程之前设置
 p.start()
p2 = Process(target=func) # 15s
 p2.start()
for i in range(100): # 10s
time.sleep(0.1)
print(''i)
p2.join()

1，start()开启一个进程

join：用join可以让主进程等待子进程结束

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

正常的子进程没有执行完的时候主进程要一直等着

2）守护进程的作用

会随着主进程的代码执行结束而结束,不会等待其他子进程

3）注意：

守护进程要在start之间设置

守护进程中不能再开启子进程

2，is_alive与terminate

multiprocessing (5( == = Process(target=0.11(p.is_alive())

p.is_alive()   # 是否活着 True代表进程还在 False代表进程不在了p.terminate()  # 结束一个进程,但是这个进程不会立刻被杀死

(5( == = Process(target== class MyProcess(Process):
def run(self):
print('wahaha',self.name,self.pID)
time.sleep(5)
print('qqxing',self.pID)
if name == 'main':
p = MyProcess()
p.start()
print(p.pID)
# pID 查看这个进程进程ID

name 查看这个进程的名字

三、锁

multiprocessing Locklock = Lock() lock.acquire() lock.acquire()

锁 就是在并发编程中 保证数据安全

multiprocessing multiprocessing def search(i):
with open('ticket') as f:
print(i,Json.load(f)['count'])

def get(i):
with open('ticket') as f:
ticket_num = Json.load(f)['count']
time.sleep(random.random())
if ticket_num > 0:
with open('ticket','w') as f:
Json.dump({'count':ticket_num-1},f)
print('%s买到票了'%i)
else:
print('%s没票了'%i)

def task(i,lock):
search(i) # 查看票
 lock.acquire()
get(i) # 抢票
 lock.release()

if name == 'main':
lock = Lock()
for i in range(20): # 20个人同时抢票
p = Process(target=task,args=(i,lock))
p.start()
import Json
import time
import random
from multiprocessing import Lock
from multiprocessing import Process

def search(i):
with open('ticket') as f:
print(i,lock))
p.start()

四、信号量

multiprocessing Semaphore multiprocessing (%1,10(% == = Semaphore(4 i range(20=sing,sem)).start()

五、事件

事件 —— 异步阻塞事件是所有的进程，都陷入阻塞

multiprocessing Event multiprocessing multiprocessing 3( 3(

def car(i,e):
e.wait()
print('%s车通过'%i)

if name == 'main':
e = Event() # 立一个红灯
tra = Process(target=traffic_light,args=(e,))
tra.start() # 启动一个进程来控制红绿灯
for i in range(100):
if i%6 == 0 :
time.sleep(random.randint(1,3))
car_pro = Process(target=car,e))
car_pro.start()

六、队列

队列进程之间的通信

1.进程之间通信 可以使用multiprocessing 的 Queue模块2.队列有两种创建方式 第一种不传参数 这个队列就没有长度限制 ；传参数，创建一个有最大长度限制的队列3.提供两个重要方法；put get4.qsize查看队列的大小

producer(q): i range(100%def consumer(q): # 消费者
for i in range(100):
time.sleep(1)
print(q.get())

if name == 'main':
q = Queue(10) # 托盘
p = Process(target=producer,args=(q,))
p.start()
c1 = Process(target=consumer,))
c2 = Process(target=consumer,))
c1.start()
c2.start()

总结

以上是内存溢出为你收集整理的python：进程 *** 作全部内容，希望文章能够帮你解决python：进程 *** 作所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/1208003.html