进程、线程、协程开启方式

__author__ = ‘admin‘
from gevent import monkey
monkey.patch_all(thread=False)
import gevent,time,os
from threading import Thread,currentThread
from multiprocessing import Process,Pool,current_process
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
def thread_fun(item):
    print(‘\033[33m <name:%s> <value:%s> <pid:%s> start...‘%(currentThread().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[33m <name:%s> <value:%s> <pid:%s> end...‘%(currentThread().name,item,os.getpid()))
def process_fun(item):
    print(‘\033[35m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[35m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
def gevent_fun(item):
    print(‘\033[36m <name:%s> <value:%s> <pid:%s> start...‘%(currentThread().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[36m <name:%s> <value:%s> <pid:%s> end...‘%(currentThread().name,item,os.getpid()))
    return item**2
def thread_pool_fun(item):
    print(‘\033[32m <name:%s> <value:%s> <pid:%s> start...‘%(currentThread().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[32m <name:%s> <value:%s> <pid:%s> end...‘%(currentThread().name,item,os.getpid()))
    return item**2
def thread_pool_fun_callback(item):
    print(‘\033[31m <name:%s> <value:%s> <pid:%s> start...‘%(currentThread().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[31m <name:%s> <value:%s> <pid:%s> end...‘%(currentThread().name,item,os.getpid()))
def process_pool_fun(item):
    print(‘\033[30m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[30m <name:%s> <value:%s> <pid:%s> end...‘%(current_process().name,item,os.getpid()))
    return item**2
def process_pool_fun_callback(item):
    print(‘\033[29m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[29m <name:%s> <value:%s> <pid:%s> end...‘%(current_process().name,item,os.getpid()))
def pool_fun(item):
    print(‘\033[28m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[28m <name:%s> <value:%s> <pid:%s> end...‘%(current_process().name,item,os.getpid()))
    return item**2
def pool_fun_callback(item):
    print(‘\033[33m <name:%s> <value:%s> <pid:%s> start...‘%(current_process().name,item,os.getpid()))
    time.sleep(1)
    print(‘\033[33m <name:%s> <value:%s> <pid:%s> end...‘%(current_process().name,item,os.getpid()))
    return item**2
if __name__ == ‘__main__‘:
    # 开启单纯进程、线程、协成的方法
    def thread(value):
        threads = []
        for i in range(value):
            t = Thread(target=thread_fun,args=(i,))
            threads.append(t)
            t.start()
        for obj in threads:
            obj.join()
        print(‘--------->thread is end‘)
    def process(value):
        processs = []
        for i in range(value):
            p = Process(target=process_fun,args=(i,))
            processs.append(p)
            p.start()
        for obj in processs:
            obj.join()
        print(‘------>process is end‘)
    def gev(value):
        Gevents = []
        for i in range(value):
            g = gevent.spawn(gevent_fun,i)
            Gevents.append(g)
        gevent.joinall(Gevents)
        res = [obj.value for obj in Gevents]
        print(res)
        print(‘------>gevent is end‘)
    def thread_pool(value):
        thp = ThreadPoolExecutor(4)
        targets = []
        for i in range(value):
            target = thp.submit(thread_pool_fun,i)
            # target = thp.submit(thread_pool_fun,i).add_done_callback(thread_pool_fun_callback)
            #这种方式使用回调函数,就不能再获取函数(第一个、第二个)的返回值,如果使用result()会报错,报错原因是没有result属性
            targets.append(target)
        thp.shutdown()
        res = [obj.result() for obj in targets]
        # obj = thp.map(thread_pool_fun,range(5))
        # res = list(obj)
        print(res)
        print(‘------>ThreadPoolExecutor is end‘)
    def process_pool(value):
        pop = ProcessPoolExecutor(4)
        targets = []
        for i in range(value):
            target = pop.submit(process_pool_fun,i)
            # target = pop.submit(process_pool_fun,i).add_done_callback(process_pool_fun_callback)
            # 这种方式使用回调函数,就不能再获取函数(第一个、第二个)的返回值,如果使用result()会报错,报错原因是没有result属性
            targets.append(target)
        pop.shutdown()
        res = [obj.result() for obj in targets]
        # obj = pop.map(process_pool_fun,range(value))
        # res = list(obj)
        print(res)
        print(‘------>ProcessPoolExecutor is end‘)
    def pool(value):
        targets = []
        p = Pool(4)
        for i in range(value):
            target = p.apply_async(func=pool_fun,args=(i,))
            # target = p.apply_async(func=pool_fun,args=(i,),callback=pool_fun_callback)
            # 注意一点的是,在回调函数下使用get()方法取得的结果仍然是第一个函数处理后的结果
            targets.append(target)
        p.close()
        p.join()
        res = [obj.get() for obj in targets]
        # obj = p.map(pool_fun,range(5))
        # obj = p.map_async(pool_fun,range(5))
        # map()函数的使用
        # res = list(obj)#第一种map的获取结果方式,是个列表
        # res = obj.get()#第二种map的获取结果方式
        print(res)
        print(‘------>processpool is end‘)
    #开启组合多进程、线程、协成的方法
    def run(process_num,thread_num,gevent_num):
        t_pool = ThreadPoolExecutor(4)
        p_pool = ProcessPoolExecutor(4)
        processs = []
        threads = []
        gevents = []
        for i in range(process_num):
            obj = p_pool.submit(process_pool_fun,i)
            processs.append(obj)
        for i in range(thread_num):
            obj = t_pool.submit(thread_pool_fun,i)
            threads.append(obj)
        for i in range(gevent_num):
            obj = gevent.spawn(gevent_fun,i)
            gevents.append(obj)
        p_pool.shutdown()
        t_pool.shutdown()
        gevent.joinall(gevents)
        p_result = [item.result() for item in processs]
        t_result = [item.result() for item in threads]
        g_value = [item.value for item in gevents]
        print(‘<p_result:%s>‘%p_result)
        print(‘<t_result:%s>‘%t_result)
        print(‘<g_value:%s>‘%g_value)
调用单纯开启进程、线程、协成的方式
    thread(5)
    process(5)
    gev(5)
    thread_pool(5)
    process_pool(5)
    pool(5)
调用混合开启进程、线程、协成的方式
    run(5,5,5)

原文地址:https://www.cnblogs.com/52-qq/p/8282416.html

时间: 2024-10-28 18:59:13

进程、线程、协程开启方式的相关文章

进程线程协程开启

__author__ = 'admin' from gevent import monkey monkey.patch_all(thread=False) import gevent,time,os from threading import Thread,currentThread from multiprocessing import Process,Pool,current_process from concurrent.futures import ProcessPoolExecutor

# 进程/线程/协程 # IO:同步/异步/阻塞/非阻塞 # greenlet gevent # 事件驱动与异步IO # Select\Poll\Epoll异步IO 以及selectors模块 # Python队列/RabbitMQ队列

1 # 进程/线程/协程 2 # IO:同步/异步/阻塞/非阻塞 3 # greenlet gevent 4 # 事件驱动与异步IO 5 # Select\Poll\Epoll异步IO 以及selectors模块 6 # Python队列/RabbitMQ队列 7 8 ############################################################################################## 9 1.什么是进程?进程和程序之间有什么

初识进程 线程 协程(三):协程

协程:(又称微线程,也是交替运行) 进程-->线程-->协程 协程就是充分利用cpu给该线程的时间,多个协程只使用一个线程,某个任务遇到阻塞,执行下一个任务.如果一个线程只执行一个任务,比较容易进入阻塞队列,如果这条线程永远在工作(协程:一个线程执行多个任务),永远不会进入阻塞队列. 适用场景:    当程序中存在大量不需要CPU的操作时(IO) 特点: 每次都能从上次暂停的位置继续执行 三种实现方式: 1.yield(生成器) 生成器:一边计算一边循环的机制 def a(): ......

python 进程 线程 协程

并发与并行:并行是指两个或者多个事件在同一时刻发生:而并发是指两个或多个事件在同一时间间隔内发生.在单核CPU下的多线程其实都只是并发,不是并行. 进程是系统资源分配的最小单位,进程的出现是为了更好的利用CPU资源使到并发成为可能.进程由操作系统调度. 线程的出现是为了降低上下文切换的消耗,提高系统的并发性,并突破一个进程只能干一样事的缺陷,使到进程内并发成为可能.线程共享进程的大部分资源,并参与CPU的调度, 当然线程自己也是拥有自己的资源的,例如,栈,寄存器等等.线程由操作系统调度. 协程通

python的进程/线程/协程

1.python的多线程 多线程就是在同一时刻执行多个不同的程序,然而python中的多线程并不能真正的实现并行,这是由于cpython解释器中的GIL(全局解释器锁)捣的鬼,这把锁保证了同一时刻只有一个线程被执行. 多线程的特点: 线程比进程更轻量级,创建一个线程要比创建一个进程快10-100倍. 线程共享全局变量. 由于GIL的原因,当一个线程遇到IO操作时,会切换到另一个线程,所以线程适合IO密集型操作. 在多核cpu系统中,最大限度的利用多核,可以开启多个线程,开销比进程小的多,但是这并

进程线程协程那些事儿

一.进程与线程 1.进程 我们电脑的应用程序,都是进程,假设我们用的电脑是单核的,cpu同时只能执行一个进程.当程序出于I/O阻塞的时候,CPU如果和程序一起等待,那就太浪费了,cpu会去执行其他的程序,此时就涉及到切换,切换前要保存上一个程序运行的状态,才能恢复,所以就需要有个东西来记录这个东西,就可以引出进程的概念了. 进程就是一个程序在一个数据集上的一次动态执行过程.进程由程序,数据集,进程控制块三部分组成.程序用来描述进程哪些功能以及如何完成:数据集是程序执行过程中所使用的资源:进程控制

进程,线程,协程的相关解释 《转载》

自己不太懂这一块,转发和大家一块分享!!! 进程,由OS来管理,每个进程都有自己独立的内存空间,进程之间通讯主要是通过信号传递的方式来实现的,实现方式有多种,信号量,管道,事件等,任何一种方式的通讯效率都需要过内核,导致通讯效率比较低.由于是独立的内存空间,所以上下文切换的时候需要保存当先调用栈的信息,cpu各寄存器的信息,虚拟内存,以及打开的相关句柄等信息,所以导致上下文切换的代价非常高,因此进程并不适合大量创建. 线程:也是由OS来管理的,一个进程可以拥有多个线程,但是其中每个线程会共享父进

Python并发编程-进程 线程 协程

一.进程 进程:就是一个程序在一个数据集上的一次动态执行过程. 进程由三部分组成: 1.程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成 2.数据集:数据集则是程序在执行过程中所需要使用的资源 3.进程控制块:进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感 知进程存在的唯一标志. 二.线程                                                                        

进程 线程 协程

进程可靠,开销大 线程共享内存,开销小 协程开销更小, python和go都有 apache是多进程,prework模式是一个进程处理一个请求 nginx也是多进程模式,一个master,多个woker,但是加入了异步非阻塞模式 mysql采用多线程,但是你ps看到的会有多个进程,是因为MySQL一直都是单进程.多线程的工作模式.只是,LinuxThreads并不是真正的线程,因此,这些进程其实还是采用系统调用 clone() 来共享同样的地址空间的.尽管采用 ps 查看的结果看起来是多进程,其