18.1 什么是进程
进程一般来说是指程序本身，运行时，就是一个进程。
18.2 创建进程的常用方式
关键字：os.fork()（nt系统不支持这个）, multiprocessing, Pool
18.2.1 使用multiprocessing模块创建进程
代码*************start
from multiprocessing import Process
def test(interval):
print("我是子线程", interval)
def main():
print("主线程开始")
p = Process(target = test, args = (1,));
p.start()
print("主线程结束");
if __name == "__main__":
main();
代码*************end
p常用方法：is_alive();join([timeout]);start();run();terminate();name;pid;
18.2.2 使用Process子类创建进程(join()方法，是等待子进程结束，再运行接下来的代码)
from multiprocessing import Process
import time
import os
class SubProcess(Process):
def __init__(self):
Process.__init__(self, interval, name)
self.interval = interval
if name:
self.name = name
def run(self):
t_start = time.time()
time.sleep(self.interval)
t_end = time.time()
print(t_end - t_start)
if __name == "__main__":
p1 = SubProcess(interval = 1, name = "mrsoft1")
p2 = SubProcess(interval = 2, name = "mrsoft2")
p1.start()
p2.start()
p1.join()
p2.join()
18.2.3 使用进程池Pool创建进程
from multiprocessing import Pool
import time, random
def task(name):
time.sleep(random.random() * 3)
print('%s %s'%(os.getpid(), name))
if __name__ == '__main__':
p = Pool(3)
for i in range(10):
p.apply_async(task, arg=(i,))
p.close()
p.join()
18.3 进程间的通信
＃ 这个程序不会出现理想中的结果，因为，二个子进程会第一时间获取还未悠的数据，而不是一个程序获取到另一个子程序获取到的程序修改后的数据
from multiprocessing import Process
def plus():
global g_num
g_num += 50
print('1_g_num is %d'%g_num)
def minus():
global g_num
g_num -= 50
print('2_g_num is %d'%g_num)
g_num = 100
if __name__ == '__main__'
p1 = Process(target = plus)
p2 = Process(target = minus)
p1.start()
p2.start()
p1.join()
p2.join()
18.3.1 队列简介
18.3.2 多进程队的使用
from multiprocessing import Queue
if __name__ == "__main__":
q = Queue(3)
q.put('msg1')
q.put('msg2')
print(q.full())
q.put('msg3')
print(q.full())
try:
q.put_nowait('msg4', true, 2);
except:
print('msg消息放满了')
try:
q.put_nowait('msg4');
except:
print('msg消息放满了')
if not q.empty():
print('--从队列中获取消息')
for i in range(q.qsize()):
print(q.get_nowait())
if not q.full():
q.put_nowait("msg4");
18.3.3 使用队列在进程间通信
from multiprocessing import Process, Queue
import time
def write_task(q):
if not q.full():
for i in range(5):
message = "msg" + str(i)
q.put(message)
print("write : %d'%message")
def read_task(q):
time.sleep(1)
while not q.empty():
print("read : %s"%q.get(true, 2)
if __name__ == "__main__"
q = Queue()
pw = Process(target = write_task, args=(q,))
pr = Precess(target = read_task, arg=(1,))
pw.start()
pr.start()
pw.join()
pw.join()
18.4 什么是线程
线程是进程的一部分，也是操作系统进行运算的最小单位
18.5 创建线程
18.5.1 使用threading 模块创建线程
创建格式：
import threading, time
Thread([group[,target[,name[,args[,kwargs]]]]])
import threading, time
def process():
for i in range(3):
time.sleep(1)
print('thread name is %s'%threading.current_thread().name)
if __name__=='__main__':
threads = [threading.Thread(target = process) for i in range(4)]
for i in threads:
i.start()
for i in threads:
i.join()
18.5.2 使用Thread子类创建线程
import threading
import time
class SubThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "name : " + self.name + str(i)
if __name__ == "__main__":
t1 = SubThread()
t2 = SubThread()
t1.start()
t2.start()
t1.join()
t2.join()
18.6 什么是互斥锁(mutual exclusion)
当一个资源被多个线程使用时，产生混乱，所出来的机制；
18.6.1 使用互斥锁
mutex = threading.Lock()
mutex.acquire(blocking)
mutex.release()
from threading import Thread, Lock
import time
n = 100
def task():
global n
mutex.acquire() # 锁定资源
temp = n
time.sleep(0.1)
n = temp - 1
print("buy successed , there are %d price"%n)
mutex.release() ＃ 释放资源
if __name__ == "__main__"
mutex = Lock()
t_1 = []
for i in range(10):
t = Thread(target = task)
t_1.append(t)
t.start()
for i in t_1:
i.join()
18.6.2 使用队列在线程间通信
from queue import Queue
import random random.threading, time
class Producer(threading.Thread):
def __init__(self, name, queue):
threading.Thread.__init__(self, name=name)
self.data = queue
def run(self):
for i range(5):
print('producer %s product + %d'%self.getName(),i)
self.data.put(i)
time.sleep(random.random())
print("producer finished")
class Consumer(threading.Thread):
def __init_(self, name, queue):
threading.Thread.__init__(self, name = name)
self.data = queue
def run(self):
for i in range(5)
val = self.data.get()
print("consumer %s product %d"%(self.getName(), val))
time.sleep(random.random())
print("counsumer finished")
if __name__ == '__main__':
queue = Queue()
producer = Producer("Producer",queue)
consumer = Consumer("Consumer",queue)
producer.start()
consumer.start()
producer.join()
producer.join()
