python-进程

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

在多道编程中，我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU，因此，进程就是为了在CPU上实现多道编程而提出的。
一句话总结：进程就是cpu的资源集合。里面包含对各种资源的调用，内存的管理，网络接口的调用等。

优点：
进程有很多优点，它提供了多道编程，让我们感觉我们每个人都拥有自己的CPU和其他资源，可以提高计算机的利用率。

缺点： 进程只能在一个时间干一件事。 进程在执行的过程中如果阻塞，整个进程就会挂起，程序也将无法执行。

import multiprocessing,time,queue

def run(name):
    time.sleep(2)
    print(‘doing....{0}‘.format(name))


if __name__ == ‘__main__‘:
    p = multiprocessing.Process(target=run,args=(‘python‘,))
    p.start()

进程之间的内存是相互独立的，但是如果需要它们之间通信交互数据而且还要共享数据，那么该怎么办呢？

from multiprocessing import Process,Queue

def p1(q):
    q.put([‘42‘,‘Non3‘,‘hello‘])


def p2(q):
    print(q.get())


if __name__ == ‘__main__‘:
    q = Queue()
    pp1 = Process(target=p1,args=(q,))
    pp2 = Process(target=p2,args=(q,))
    pp1.start()
    pp2.start()

from multiprocessing import Process,Pipe
def p1(conn):
    conn.send(‘message from other process‘)
    print(conn.recv())
    conn.close()

if __name__ == ‘__main__‘:
    p_conn,c_conn = Pipe()
    p = Process(target=p1,args=(c_conn,))
    p.start()
    p_conn.send(‘good good study day day up‘)
    print(p_conn.recv())
    p.join()

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[1] = ‘1‘
    d[‘2‘] = 2
    d["pid%s" %os.getpid()] = os.getpid()
    l.append(1)
    print(l,d)


if __name__ == ‘__main__‘:
    with Manager() as manager:
        d = manager.dict()

        l = manager.list(range(5))

        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()
        l.append("from parent")
        print(d)
        print(l)

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：

apply
apply_async

from multiprocessing import Process,Pool
import os,time

def pool_func(pid):
    time.sleep(1)
    print(‘Process is {0}‘.format(os.getpid()))
    return [pid,os.getpid()]

def call_back(res):
    print(‘call_back,main_process:{0},sub_process:{1}‘.format(res[0],res[1]))


if __name__ == ‘__main__‘:
    pool = Pool(processes=3)

    print(os.getpid())
    for i in range(8):
        """串行"""
        # pool.apply(func=pool_func)
        """并行"""
        pool.apply_async(func=pool_func,args=(os.getpid(),),callback=call_back)
    print(‘end...‘)
    pool.close()
    pool.join() #   等待进程结束。

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

"""
    先入先出。
    queue = queue.Queue()
    queue.put(1)
    queue.put(2)
    queue.put(3)
    print(queue.get())
    print(queue.get())
    print(queue.get())
"""
"""
    先入后出。
    queue = queue.LifoQueue()

    queue.put(1)
    queue.put(2)
    queue.put(3)
    print(queue.get())
    print(queue.get())
    print(queue.get())
"""
"""
    自定义队列执行顺序
    queue = queue.PriorityQueue()

    queue.put((8,‘111‘))
    queue.put((2,‘dfff‘))
    queue.put((-1,‘dddd‘))
    queue.put((20,‘yyyyy‘))
    print(queue.get())
    print(queue.get())
    print(queue.get())
    print(queue.get())
"""

"""
queue 队列。必会。
实例：染布流水生产线
有一条染布流水生产线，一边负责把布匹放入染池，一边负责取出染布。
如果布匹染完则啥都不干。
"""
import queue,time,threading
cloth_queue = queue.Queue()
def put_cloth():

    for num in range(10):
        """布匹依次放入染池中"""
        cloth_queue.put(‘cloth_{}‘.format(num))
        print(‘put cloth_{} ...‘.format(num))
        time.sleep(0.8)

def get_cloth():
    while True:
        if cloth_queue.qsize()>0:
            time.sleep(1)
            print(‘get {0} ...‘.format(cloth_queue.get()))
        elif cloth_queue.qsize()==0:
            print(‘end...‘)
            break


t_queue_put = threading.Thread(target=put_cloth,)
t_queue_put.start()

t_queue_get = threading.Thread(target=get_cloth,)
t_queue_get.start()