码迷,mamicode.com
首页 > 编程语言 > 详细

python-进程

时间:2018-05-26 13:03:08      阅读:33      评论:0      收藏:0      [点我收藏+]

标签:就是   break   join   imp   turn   style   orm   计算   end   

1.什么是进程?

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

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

2.进程的优点和确定。

优点:
进程有很多优点,它提供了多道编程,让我们感觉我们每个人都拥有自己的CPU和其他资源,可以提高计算机的利用率。
缺点: 进程只能在一个时间干一件事。 进程在执行的过程中如果阻塞,整个进程就会挂起,程序也将无法执行。

3.进程的简单使用。

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()

4.进程之间的通信。

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

4.1.利用queue传值通信。

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()

4.2 利用Pipe()管道通信。

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()

4.3 利用Manager()共享数据

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)

5.进程池

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

进程池中有两个方法:

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() #   等待进程结束。

 6.队列queue

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

python queue队列中的几种模式。

"""
    先入先出。
    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()

 

python-进程

标签:就是   break   join   imp   turn   style   orm   计算   end   

原文地址:https://www.cnblogs.com/yzhl/p/9092458.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!