Python之多进程与多线程的使用

进程与线程

想象在学校的一个机房，有固定数量的电脑，老师安排了一个爬虫任务让大家一起完成，每个学生使用一台电脑爬取部分数据，将数据放到一个公共数据库。共同资源就像公共数据库，进程就像每一个学生，每多一个学生，就多一个进程来完成这个任务，机房里的电脑数量就像CPU，所以进程数量是CPU决定的，线程就像学生用一台电脑开多个爬虫，爬虫数量由每台电脑的运行内存决定。
一个CPU可以有多个进程，一个进程有一个或多个线程。

多进程

1、导包

from multiprocessing import Process

2、写两个任务
也就是两个函数

3、创建一个进程
进程名字 = Process(target=函数名字，函数参数传字典或元组，是否守护进程)

4、启动进程
进程名字.start()

5、是否开启进程守护，一般主进程会等待子进程执行完毕后再关闭程序。当我们想程序主进程跑完，直接销毁掉未完成的子进程，关闭程序的话，加上一句代码 ：
1.创建进程的时候传参数daemon=True
2.进程名字.daemon=True

6、进程编号
导包os
获取当前进程编号

os.getpid()

获取当前父进程的编号

os.getppid()

代码示例（未开启进程守护）

from multiprocessing import Process
import time
import os

# 一个写作业函数
def homeWork(name, count):
  for i in range(count):
    # 打印当前进程编号os.getpid()
    print("当前进程编号:", os.getpid())

    # 打印当前父进程编号os.getppid()
    print("当前父进程编号:", os.getppid())

    print(name, "正在写作业...")
    time.sleep(0.2)
# 一个打游戏函数
def game(name, count):
  for i in range(count):
    # 打印当前进程编号os.getpid()
    print("当前进程编号:", os.getpid())

    # 打印当前父进程编号os.getppid()
    print("当前父进程编号:", os.getppid())

    print(name, "正在打游戏...")
    time.sleep(0.2)

if __name__ == '__main__':
  # 打印当前进程编号os.getpid()
  print("当前进程编号:", os.getpid())

  # 进程1写作业 元组传参
  p1 = Process(target=homeWork, args=("进程1", 10))
  # 进程2打游戏 字典传参
  p2 = Process(target=game, kwargs={"name": "进程2", "count": 10})

  # 启动进程
  p1.start()
  p2.start()
  time.sleep(1)
  print("主进程结束---------------------------------------------")

未开启线程守护的运行结果：

# 可以看到主进程结束的，其子进程还在继续
当前进程编号: 14972
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
主进程结束---------------------------------------------
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...
当前进程编号: 5732
当前父进程编号: 14972
进程1 正在写作业...
当前进程编号: 14752
当前父进程编号: 14972
进程2 正在打游戏...

Process finished with exit code 0

代码示例（开启进程守护）

from multiprocessing import Process
import time
import os

# 一个写作业函数
def homeWork(name, count):
  for i in range(count):
    # 打印当前进程编号os.getpid()
    print("当前进程编号:", os.getpid())

    # 打印当前父进程编号os.getppid()
    print("当前父进程编号:", os.getppid())

    print(name, "正在写作业...")
    time.sleep(0.2)
# 一个打游戏函数
def game(name, count):
  for i in range(count):
    # 打印当前进程编号os.getpid()
    print("当前进程编号:", os.getpid())

    # 打印当前父进程编号os.getppid()
    print("当前父进程编号:", os.getppid())

    print(name, "正在打游戏...")
    time.sleep(0.2)

if __name__ == '__main__':
  # 打印当前进程编号os.getpid()
  print("当前进程编号:", os.getpid())

  # 进程1写作业 元组传参 第一种方法启动进程守护
  p1 = Process(target=homeWork, args=("进程1", 10), daemon=True)
  # 进程2打游戏 字典传参
  p2 = Process(target=game, kwargs={"name": "进程2", "count": 10})
  # 第二种
  p2.daemon = True
  # 启动进程
  p1.start()
  p2.start()
  time.sleep(1)
  print("主进程---------------------------------------------")

开启进程守护的运行结果

当前进程编号: 372
当前进程编号: 10116
当前进程编号: 9860
当前父进程编号: 372
进程1 正在写作业...
当前父进程编号: 372
进程2 正在打游戏...
当前进程编号: 9860
当前进程编号: 10116
当前父进程编号: 372
进程2 正在打游戏...
当前父进程编号: 372
进程1 正在写作业...
当前进程编号: 9860
当前进程编号: 10116
当前父进程编号: 372
进程1 正在写作业...
当前父进程编号: 372
进程2 正在打游戏...
当前进程编号: 9860
当前进程编号: 10116
当前父进程编号: 372
进程1 正在写作业...
当前父进程编号: 372
进程2 正在打游戏...
主进程结束---------------------------------------------

Process finished with exit code 0

多线程

1、导包

import threading

2、写两个任务
也就是两个函数

3、创建一个线程
线程名字 = threading.Thread(target=函数名字，函数参数传字典或元组，是否守护进程)

4、启动线程
线程名字.start()

5、是否开启线程守护，一般当前程序会等待子线程执行完毕后再关闭程序。当我们想程序跑完，销毁掉未完成的子线程，直接关闭程序的话，加上一句代码 ：
1.创建线程的时候传参数daemon=True
2.线程名字.daemon=True

6、线程编号
获取当前线程编号

threading.current_thread()

代码示例（未开启进程守护）

import threading
import time

# 一个写作业函数
def homeWork(name, count):
  for i in range(count):
    # 打印当前线程
    print(threading.current_thread())
    print(name, "正在写作业...")
    time.sleep(0.2)
# 一个打游戏函数
def game(name, count):
  for i in range(count):
    # 打印当前线程
    print(threading.current_thread())
    print(name, "正在打游戏...")
    time.sleep(0.2)

if __name__ == '__main__':

  # 线程1写作业 元组传参
  t1 = threading.Thread(target=homeWork, args=("进程1", 10))
  # 线程2打游戏 字典传参
  t2 = threading.Thread(target=game, kwargs={"name": "进程2", "count": 10})

  # 启动进程
  t1.start()
  t2.start()
  time.sleep(1)
  print("主进程结束###################################################################################")

未开启线程守护的运行结果

# 可以看到主进程结束的，其线程还在继续
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
主进程结束###################################################################################
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-1, started 3364)>
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...进程1
正在写作业...
<Thread(Thread-1, started 3364)>
进程1 正在写作业...
<Thread(Thread-2, started 9100)>
进程2 正在打游戏...
<Thread(Thread-2, started 9100)><Thread(Thread-1, started 3364)>
进程1
进程2正在写作业...
 正在打游戏...
<Thread(Thread-2, started 9100)><Thread(Thread-1, started 3364)>

进程2 进程1 正在打游戏...
正在写作业...

Process finished with exit code 0

代码示例（开启线程守护）

import threading
import time

# 一个写作业函数
def homeWork(name, count):
  for i in range(count):
    # 打印当前线程
    print(threading.current_thread())
    print(name, "正在写作业...")
    time.sleep(0.2)
# 一个打游戏函数
def game(name, count):
  for i in range(count):
    # 打印当前线程
    print(threading.current_thread())
    print(name, "正在打游戏...")
    time.sleep(0.2)

if __name__ == '__main__':

  # 线程1写作业 元组传参
  t1 = threading.Thread(target=homeWork, args=("进程1", 10), daemon=True)
  # 线程2打游戏 字典传参
  t2 = threading.Thread(target=game, kwargs={"name": "进程2", "count": 10})
  t2.daemon = True

  # 启动进程
  t1.start()
  t2.start()
  time.sleep(1)
  print("主进程结束###################################################################################")

开启线程守护的运行结果

<Thread(Thread-1, started daemon 15480)>
进程1 正在写作业...
<Thread(Thread-2, started daemon 13700)>
进程2 正在打游戏...
<Thread(Thread-2, started daemon 13700)>
进程2 正在打游戏...
<Thread(Thread-1, started daemon 15480)>
进程1 正在写作业...
<Thread(Thread-1, started daemon 15480)><Thread(Thread-2, started daemon 13700)>
进程1
进程2 正在写作业...正在打游戏...

<Thread(Thread-2, started daemon 13700)><Thread(Thread-1, started daemon 15480)>

进程1进程2 正在写作业... 正在打游戏...

<Thread(Thread-1, started daemon 15480)>
进程1 正在写作业...
<Thread(Thread-2, started daemon 13700)>
进程2 正在打游戏...
主进程结束###################################################################################

Process finished with exit code 0

到此这篇关于Python之多进程与多线程的使用的文章就介绍到这了,更多相关Python 多进程与多线程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • python并发编程之多进程、多线程、异步和协程详解

    最近学习python并发,于是对多进程.多线程.异步和协程做了个总结. 一.多线程 多线程就是允许一个进程内存在多个控制权,以便让多个函数同时处于激活状态,从而让多个函数的操作同时运行.即使是单CPU的计算机,也可以通过不停地在不同线程的指令间切换,从而造成多线程同时运行的效果. 多线程相当于一个并发(concunrrency)系统.并发系统一般同时执行多个任务.如果多个任务可以共享资源,特别是同时写入某个变量的时候,就需要解决同步的问题,比如多线程火车售票系统:两个指令,一个指令检查票是否卖完

  • python多线程与多进程及其区别详解

    前言 个人一直觉得对学习任何知识而言,概念是相当重要的.掌握了概念和原理,细节可以留给实践去推敲.掌握的关键在于理解,通过具体的实例和实际操作来感性的体会概念和原理可以起到很好的效果.本文通过一些具体的例子简单介绍一下python的多线程和多进程,后续会写一些进程通信和线程通信的一些文章. python多线程 python中提供两个标准库thread和threading用于对线程的支持,python3中已放弃对前者的支持,后者是一种更高层次封装的线程库,接下来均以后者为例. 创建线程 pytho

  • 处理python中多线程与多进程中的数据共享问题

    之前在写多线程与多进程的时候,因为一般情况下都是各自完成各自的任务,各个子线程或者各个子进程之前并没有太多的联系,如果需要通信的话我会使用队列或者数据库来完成,但是最近我在写一些多线程与多进程的代码时,发现如果它们需要用到共享变量的话,需要有一些注意的地方 多线程之间的共享数据 标准数据类型在线程间共享 看以下代码 #coding:utf-8 import threading def test(name,data): print("in thread {} name is {}".fo

  • Python实现的自定义多线程多进程类示例

    本文实例讲述了Python实现的自定义多线程多进程类.分享给大家供大家参考,具体如下: 最近经常使用到对大量文件进行操作的程序以前每次写的时候都要在函数中再写一个多线程多进程的函数,做了些重复的工作遇到新的任务时还要重写,因此将多线程与多进程的一些简单功能写成一个类,方便使用.功能简单只为以后方便使用. 使用中发现bug会再进行更新 #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2017/5/10 12:47 # @Author

  • Python2.7实现多进程下开发多线程示例

    简单的基于Python2.7版本的多进程下开发多线程的示例,供大家参考,具体内容如下 可以使得程序执行效率至少提升10倍 #!/usr/bin/env python # -*- coding: utf-8 -*- """ @Time : 2018/10/24 @Author : LiuXueWen @Site : @File : transfer.py @Software: PyCharm @Description: """ import os

  • python多进程和多线程究竟谁更快(详解)

    python多进程和多线程究竟谁更快(详解)

    python3.6 threading和multiprocessing 四核+三星250G-850-SSD 自从用多进程和多线程进行编程,一致没搞懂到底谁更快.网上很多都说python多进程更快,因为GIL(全局解释器锁).但是我在写代码的时候,测试时间却是多线程更快,所以这到底是怎么回事?最近再做分词工作,原来的代码速度太慢,想提速,所以来探求一下有效方法(文末有代码和效果图) 这里先来一张程序的结果图,说明线程和进程谁更快 一些定义 并行是指两个或者多个事件在同一时刻发生.并发是指两个或多个

  • Python多线程处理实例详解【单进程/多进程】

    Python多线程处理实例详解【单进程/多进程】

    本文实例讲述了Python多线程处理操作.分享给大家供大家参考,具体如下: python - 多线程处理 1.一个进程执行完后,继续下一个进程 root@72132server:~# cd /root/python/multiprocess/ root@72132server:~/python/multiprocess# ls multprocess.py root@72132server:~/python/multiprocess# cat multprocess.py #!/usr/bin/

  • 浅析Python中的多进程与多线程的使用

    在批评Python的讨论中,常常说起Python多线程是多么的难用.还有人对 global interpreter lock(也被亲切的称为"GIL")指指点点,说它阻碍了Python的多线程程序同时运行.因此,如果你是从其他语言(比如C++或Java)转过来的话,Python线程模块并不会像你想象的那样去运行.必须要说明的是,我们还是可以用Python写出能并发或并行的代码,并且能带来性能的显著提升,只要你能顾及到一些事情.如果你还没看过的话,我建议你看看Eqbal Quran的文章

  • Python实现多线程/多进程的TCP服务器

    多线程的TCP服务器,供大家参考,具体内容如下 背景:同学公司的传感器设备需要将收集的数据发到服务器上,前期想写一个简单的服务器来测试下使用效果,设备收集的数据非常的重要,所以考虑使用TCP协议来实现. 因为只是测试使用,所以采用多线程的方式,毕竟节省资源嘛(使用协程时会导致I/O阻塞) 开门见山,直接搬上来了 一.tcp_server_v1.0使用说明: 1.运行环境:python3解释器,并安装socket.threading模块: 2.该版本使用多线程实现的多任务: 3.支持多台设备同时连

  • Python多进程并发与多线程并发编程实例总结

    本文实例总结了Python多进程并发与多线程并发.分享给大家供大家参考,具体如下: 这里对python支持的几种并发方式进行简单的总结. Python支持的并发分为多线程并发与多进程并发(异步IO本文不涉及).概念上来说,多进程并发即运行多个独立的程序,优势在于并发处理的任务都由操作系统管理,不足之处在于程序与各进程之间的通信和数据共享不方便:多线程并发则由程序员管理并发处理的任务,这种并发方式可以方便地在线程间共享数据(前提是不能互斥).Python对多线程和多进程的支持都比一般编程语言更高级

  • Python多线程、异步＋多进程爬虫实现代码

    安装Tornado 省事点可以直接用grequests库,下面用的是tornado的异步client. 异步用到了tornado,根据官方文档的例子修改得到一个简单的异步爬虫类.可以参考下最新的文档学习下. pip install tornado 异步爬虫 #!/usr/bin/env python # -*- coding:utf-8 -*- import time from datetime import timedelta from tornado import httpclient, g

随机推荐