CSIC_716_20191207【并发编程---进程与线程】

僵尸进程与孤儿进程

 ...........

 

守护进程

from Multiprocessing  import Process

在 suboprocess.start( ) 的上一行，增加 subprocess.deamon( )，创建守护进程。当主进程执行完成时，subprocess也会被强制结束。

 

进程之间是相互独立的，主子两个进程在执行时，数据是隔离的。

 

进程、线程互斥锁：

from Multiprocessing import Lock

from threading import Lock

lock = Lock( )

lock.acquire( )　　#加锁

lock.release( )　　#释放锁

进程互斥锁是为了保证数据的读写安全。避免并发造成数据的错乱。

 

 

队列

队列可以使得进程之间的数据可以交互。

队列遵循先进先出(FIFO)的原则.

python中可以使用队列的三种方法

from multiprocessing import Queue
from multiprocessing import JoinableQueue  # 基于Queue封装的
import queue  # 内置的队列

q_obj = Queue(count)  # 对应 import Queue，规定队列中能存放几个值，count为数量
q_obj = JoinableQueue(count)  # 对应 import JoinableQueue
q_obj = queue.Queue(count)  # 对应 import queue，以上三种方式，三选一。

q_obj.put_nowait(args)  # 给队列中增加值，如果队列中满了，就会报错
q_obj.put(args)  # 给队列中增加值， 如果队列满了，就会阻塞等待

q_obj.get_nowait()  # 从队列中取值，如果取不到值，就会报错。
q_obj.get()  # 从队列中取值，如果取不到，就会阻塞等待

　　

 IPC机制    Interprocess conmunication 进程间通信，在产生子进程时，将队列作为参数传入

 

生产者和消费者模型    基于队列，在producer 和consumer之间交互信息。

 

 

线程

进程是资源单位，开启一个进程，会自动开启一个主线程。

线程是执行单位，开启一个进程会。

IO密集型的程序，做成多线程，计算密集型的程序，做成多进程。

 

 

守护线程

主线程要盯着非守护线程结束，主线程才结束，线程上加了 deamon的就是守护线程

守护线程盯着主线程，主线程结束，守护线程立即陪葬。

 

 

线程池和进程池

from  concurrent.futures　import  ThreadPoolExecutor(多线程)      ProcessPoolExecutor(多进程)

pool = ThreadPoolExecutor（数量）、ProcessPoolExecutor（数量）

pool.submit( 函数方法名，参数  )

pool.shutdown( wait = True )   暂停往池子里加东西

 

 

异步调用与回调机制

 

同步调用

取值用    .result（）

# _*_ coding: gbk _*_
# @Author: Wonder

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import os

def task1(num):
    print('%s start calculation PID: %s' % (current_thread().getName(), os.getpid()))
    res = num ** 2
    return res

def task2(a):
    print(a)

if __name__ == '__main__':
    pool = ThreadPoolExecutor(5)
    for i in range(50):
        res = pool.submit(task1, i).result()  # pool.submit(task1, i)对象的返回值，使用result()
        print(res)
    pool.shutdown(wait=True)

　　

 

异步调用

# _*_ coding: gbk _*_
# @Author: Wonder

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import os


def task1(num):
    print('线程：%s开始计算，其进程PID: %s' % (current_thread().getName(), os.getpid()))
    res = num ** 2
    return res


def task2(a):
    print(a)  # <Future at 0x2587d4e28c8 state=finished returned int>  是一个对象
    a = a.result()  # 对象取值，用result（）
    print('平方结果为:%s' % a)


if __name__ == '__main__':
    pool = ThreadPoolExecutor(5)
    for i in range(50):
        pool.submit(task1, i).add_done_callback(task2)  # add_done_callback()回调函数,执行task2
    pool.shutdown(wait=True)

a.result( )　# 对象取值　

pool.submit(task1, i).add_done_callback(task2) --------->回调函数，执行完task1 后，自动去执行task2