python多线程基础1

待我称王封你为后i 2022-10-30 15:30 137阅读 0赞

> **文章最前**： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人[github][] ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

**相关文章：**

1.  **[python多线程基础1][python_1]**
2.  **[python多线程基础2][python_2]**
3.  **[python线程基础3][python_3]**

--------------------

**文章目录:**

进程

进程池

--------------------

在现实生活中，有很多场景中的事情是同时进行的。例如：开车的时候，手和脚需要共同操作来完成驾驶。再比如演唱会中唱歌和跳舞也是同时进行的。如果把唱歌和跳舞这两件事情分开依次来完成，估计效果不是很好。

# -*- coding:utf-8 -*-
    '''
    author:zhangyu
    date:2021/2/13
    description:唱歌和跳舞
    '''
    from time import sleep
    
    
    def sing() -> None:
        '''
            唱歌
        Returns:
            None
        '''
        for i in range(3):
            print('正在唱歌...%d' % i)
            dance()
            sleep(1)
    
    
    def dance() -> None:
        '''
            跳舞
        Returns:
            None
        '''
        for i in range(3):
            print('正在跳舞...%d' % i)
            sleep(1)
    
    
    if __name__ == '__main__':
        sing()
        # dance()

从上面的示例可以看出，程序并没有完成唱歌和跳舞同时进行的要求，如果想要实现“唱歌和跳舞”同时进行，那么就需要一个新的方法，叫做：多任务。

什么叫做多任务呢？简单的说，就是操作系统可以同时进行多个任务。例如：你一边在使用浏览器上网，一边在听MP3，一边在用word赶作业，这就是多任务。

--------------------

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

### **进程**  ###

程序编写完没有运行称之为程序。正在运行的代码就是进程。在Python3语言中，对多进程支持的是multiprocessing模块和subprocess模块。multiprocessing模块为在子进程中运行任务、通讯和共享数据，以及执行各种形式的同步提供支持。

# -*- coding:utf-8 -*-
    '''
    author:zhangyu
    date:2021/2/13
    description:创建子进程并运行
    '''
    from multiprocessing import Process
    
    
    def run_test() -> None:
        '''
            运行例子
        Returns:
            None
        '''
        print('。。。test.....')
    
    
    if __name__ == '__main__':
        print('主进程执行')
        # 创建子进程 target接收执行的任务
        p = Process(target=run_test)
        # 调用子进程
        p.start()
        print('主进程结束')

进程中带有属性:

# -*- coding:utf-8 -*-
    '''
    author:zhangyu
    date:2021/2/13
    description:创建子进程并传递参数
    '''
    from multiprocessing import Process
    
    
    # 定义任务的函数
    def run_test(name, age, **kwargs) -> None:
        '''
            运行方法
        Args:
            name: 名字
            age: 年龄
            **kwargs: 字典
        Returns:
            None
        '''
        print('子进程正在运行 name的值:%s ,age的值：%d' % (name, age))
        print('字典kwargs:', kwargs)
    
    
    if __name__ == '__main__':
        print('主进程开始执行')
        # 创建子进程
        # p=Process(target=run_test,args=('test',),kwargs={'key':12})
        p = Process(target=run_test, args=('test', 23), kwargs={'key': 12})
        # 调用子进程
        p.start()

join操作:

#!/usr/bin/env python
    # -*- encoding: utf-8 -*-
    '''
    @description:   join的操作
    @date     :2021/02/18 14:16:38
    @author      :zhangyu
    @version      :1.0
    '''
    from multiprocessing import Process
    from time import sleep
    
    
    def worker(interval: float) -> None:
        """
            工作方法
        @interval  : 间隔时间
        @Returns  :
            None
        """
        print('work start')
        sleep(interval)
        print('work end')
    
    
    if __name__ == '__main__':
        print('主进程正在执行')
        # 创建子进程
        p = Process(target=worker, args=(5,))
        # 调用子进程
        p.start()
        # 希望下面的输出语句，再子进程执行完才输出
        # sleep(4)
        # 调用join方法 ：主进程等待调用join的子进程结束
        p.join()
        print('主进程执行完')

### **进程池** ###

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。

Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程。

# -*- coding:utf-8 -*-
    '''
    author:zhangyu
    date:2021/2/13
    description:测试线程池
    '''
    import multiprocessing
    import time
    
    
    def func(msg: str) -> None:
        """
            进程执行的任务函数
        @msg  : 消息
        @Returns  :
            None
        """
        print('start:', msg)
        time.sleep(3)
        print('end:', msg)
    
    
    if __name__ == '__main__':
        # 创建初始化3的进程池
        pool = multiprocessing.Pool(3)
        # 添加任务
        for i in range(1, 6):
            msg = '任务%d' % i
            pool.apply_async(func, (msg,))
    
        # 如果进程池不再接收新的请求 调用close
        pool.close()
        # 等待子进程结束
        pool.join()

**进程间通信**

全局变量在多个进程中不共享，进程之间的数据是独立的，默认情况下互不影响。

# -*- coding:utf-8 -*-
    '''
    author:zhangyu
    date:2021/2/13
    description:多进程之间通信2
    '''
    from multiprocessing import Process, Pool, Manager
    from multiprocessing.managers import SyncManager
    from time import sleep
    
    
    def write(q: SyncManager) -> None:
        '''
            定义写入的方法
        Args:
            q: 队列
        Returns:
            写队列
        '''
        elements = ['a', 'b', 'c', 'd']
        for e in elements:
            print('开始写入的值：%s' % e)
            q.put(e)
            sleep(1)
    
    
    def reader(q: SyncManager) -> None:
        '''
                读的方法
            Args:
                q: 队列
            Returns:
                写队列
            '''
        for i in range(q.qsize()):
            print('读取到的值：%s' % q.get())
            sleep(1)
    
    
    if __name__ == '__main__':
        # 创建队列
        q = Manager().Queue()
        # 创建进程
        pool = Pool(3)
        pool.apply(write, (q,))
        pool.apply(reader, (q,))
        pool.close()
        pool.join()

[github]: https://github.com/zhangyu345293721
[python_1]: https://blog.csdn.net/zy345293721/article/details/113879728
[python_2]: https://blog.csdn.net/zy345293721/article/details/113880111
[python_3]: https://blog.csdn.net/zy345293721/article/details/113882616