python中的多线程和多进程,python是单进程还是多进程

2022-08-25 01:34:47 分类：python 阅读()

　　python中的多线程和多进程,python是单进程还是多进程

　　本文主要介绍Python中多进程的深入分析。“Python中的多进程是通过多处理包实现的，类似于线程化。线程，它可以使用多重处理。过程对象来创建过程对象。

　　00-1010前言1。创建流程2。多重进程中的队列3。多进程和多线程的性能比较4。进程池pool5。共享内存6。进程锁锁

　　

目录

　　现在我们的计算机都是多核，也就是通常所说的多个处理或计算单元。为了加快运算处理速度，我们可以把不同的任务交给多个内核同时处理，从而提高运算速度和效率。多核同时运行意味着多个进程同时进行，称为多进程。

　　

前言

　　创建进程和线程的方法基本上是一样的，请看下面代码：.

　　#编码：utf-8

　　#导入多进程包并将其重命名为mp。

　　将多处理作为mp导入

　　#主要工作

　　定义p1():

　　打印( zxy )

　　if __name__==__main__:

　　#创建新流程

　　新流程=mp。进程(目标=p1，名称=p1 )

　　#开始这个过程

　　new_process.start()

　　#阻止该过程

　　new_process.join()

　　控制台效果图：

　　

1.创建进程

　　为什么在多个进程中使用队列？

　　因为多进程和多线程是一样的，在工作函数中，进程函数中的结果是不能通过return返回的，所以使用queue来存储结果，然后在需要的时候取出来。

　　#编码：utf-8

　　导入时间

　　将多处理作为mp导入

　　使用多个进程时，运行程序所需的时间。

　　定义工作1(q):

　　res=0

　　对于范围(100):内的I

　　res=i i**5 i**8

　　时间.睡眠(0.1)

　　#将结果放入队列中

　　q.put(res)

　　定义作业2(q):

　　res=0

　　对于范围(100):内的I

　　res=i i**5 i**8

　　时间.睡眠(0.1)

　　q.put(res)

　　if __name__==__main__:

　　start_time=time.time()

　　#创建队列

　　q=mp。队列()

　　#创建流程1

　　流程1=mp。进程(target=job1，args=(q，))

　　#创建流程2

　　过程2=mp。进程(target=job2，args=(q，))

　　process1.start()

　　process2.start()

　　#通过队列获取值

　　res1=q.get()

　　res2=q.get()

　　Print(res1是%d，res2是%d% (res1，res2))

　　end_time=time.time()

　　Print(整个过程花费了%s %(end_time-start_time))

　　效果图：

　　

2.多进程中的Queue

　　接下来使用多进程、多线程、无的常用方法，看看三种方法效率如何。

　　#编码：utf-8

　　将多处理作为mp导入

　　导入时间

　　将线程作为th导入

　　多进程、多线程和常用方法的性能比较

　　#多流程工作

　　定义mp_job(资源):

　　对于范围内的I(10000000)

　　:

　　 res += i**5 + i**6

　　 print(res)

　　# 多线程工作

　　def mt_job(res):

　　 for i in range(10000000):

　　 res += i**5 + i**6

　　 print(res)

　　# 普通方法工作

　　def normal_job(res):

　　 for i in range(10000000):

　　 res += i ** 5 + i ** 6

　　 print(res)

　　if __name__ == "__main__":

　　 mp_sum = 0

　　 mp_start = time.time()

　　 process1 =mp.Process(target=mp_job, args=(mp_sum, ))

　　 process2 = mp.Process(target=mp_job, args=(mp_sum,))

　　 process1.start()

　　 process2.start()

　　 process1.join()

　　 process2.join()

　　 mp_end = time.time()

　　 print("多进程使用时间为", (mp_end-mp_start))

　　 mt_start = time.time()

　　 mt_sum = 0

　　 thread1 = th.Thread(target=mt_job, args=(mt_sum, ))

　　 thread2 = th.Thread(target=mt_job, args=(mt_sum, ))

　　 thread1.start()

　　 thread2.start()

　　 thread1.join()

　　 thread2.join()

　　 mt_end = time.time()

　　 print("多线程使用的时间是", (mt_end-mt_start))

　　 normal_start = time.time()

　　 normal_sum = 0

　　 # 进行两次

　　 normal_job(normal_sum)

　　 normal_job(normal_sum)

　　 normal_end = time.time()

　　 print("普通方法使用的时间是", (normal_end-normal_start))

　　效果图：

　　

　　实验结果表明：多进程的效率确实高！！！

　　

　　

4.进程池pool

　　进程池是干什么用的呢？
进程池就是python的多进程提供的一个池子，将所有的进程都放在这个池子里面，让计算机自己去使用进程池中的资源，从而多进程处理一些程序，进而提高工作效率。

　　(1)默认使用进程池中全部进程时

　　

# coding:utf-8
　　import time
　　import multiprocessing as mp
　　"""
　　 进程池pool的使用
　　"""
　　def job(num):
　　 time.sleep(1)
　　 return num * num
　　if __name__ == "__main__":
　　 start_time = time.time()
　　 # 括号里面不加参数时，默认使用进程池中所有进程
　　 pool = mp.Pool()
　　 res = pool.map(job, range(10))
　　 print(res)
　　 end_time = time.time()
　　 print("运行时间为", (end_time-start_time))

　　效果图：

　　

　　（2）指定进程池中进程数时

　　

# coding:utf-8
　　import time
　　import multiprocessing as mp
　　"""
　　 进程池pool的使用
　　"""
　　def job(num):
　　 time.sleep(1)
　　 return num * num
　　if __name__ == "__main__":
　　 start_time = time.time()
　　 # 括号里面加参数时，指定两个进程进行处理
　　 pool = mp.Pool(processes=2)
　　 res = pool.map(job, range(10))
　　 print(res)
　　 end_time = time.time()
　　 print("运行时间为", (end_time-start_time))

　　效果图：

　　

　　（3）不使用多进程时

　　

# coding:utf-8
　　import time
　　def job(res):
　　 for i in range(10):
　　 res.append(i*i)
　　 time.sleep(1)
　　if __name__ == "__main__":
　　 start_time = time.time()
　　 res = []
　　 job(res)
　　 print(res)
　　 end_time =time.time()
　　 print("不使用进程池所用时间为", (end_time-start_time))

　　效果图：

　　

　　实验结论：多进程处理事情，效率很高！！！核心越多，处理越快！

　　

　　

5.共享内存

　　一个核心，我们多线程处理时，可以使用全局变量来共享数据。但是多进程之间是不行的，那我们多进程之间应该如何共享数据呢？
那就得用到共享内存了！

　　

# coding:utf-8
　　import multiprocessing as mp
　　"""
　　 共享内存
　　"""
　　if __name__ == "__main__":
　　 # 第一个参数是数据类型的代码，i代表整数类型
　　 # 第二个参数是共享数据的值
　　 v = mp.Value("i", 0)

　　

　　

6.进程锁lock

　　进程锁和线程锁的用法基本一致。进程锁的诞生是为了避免多进程之间抢占共享数据，进而造成多进程之间混乱修改共享内存的局面。

　　（1）不加锁之前

　　

# coding:utf-8
　　import multiprocessing as mp
　　import time
　　"""
　　 进程中的锁lock
　　"""
　　def job(v, num):
　　 for i in range(10):
　　 v.value += num
　　 print(v.value)
　　 time.sleep(0.2)
　　if __name__ == "__main__":
　　 # 多进程中的共享内存
　　 v = mp.Value("i", 0)
　　 # 进程1让共享变量每次加1
　　 process1 = mp.Process(target=job, args=(v, 1))
　　 # 进程2让共享变量每次加3
　　 process2 = mp.Process(target=job, args=(v, 3))
　　 process1.start()
　　 process2.start()

　　效果图：

　　

　　（2）加锁之后

　　

# coding:utf-8
　　import multiprocessing as mp
　　import time
　　"""
　　 进程中的锁lock
　　"""
　　def job(v, num, l):
　　 # 加锁
　　 l.acquire()
　　 for i in range(10):
　　 v.value += num
　　 print(v.value)
　　 time.sleep(0.2)
　　 # 解锁
　　 l.release()
　　if __name__ == "__main__":
　　 # 创建进程锁
　　 l = mp.Lock()
　　 # 多进程中的共享内存
　　 v = mp.Value("i", 0)
　　 process1 = mp.Process(target=job, args=(v, 1, l))
　　 process2 = mp.Process(target=job, args=(v, 3, l))
　　 process1.start()
　　 process2.start()

　　效果图：

　　

　　到此这篇关于深入解析Python中的多进程的文章就介绍到这了,更多相关Python多进程内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • pthread线程包常用函数,pthread多线程编程
  • c 多线程编程,c多线程编程实例
  • c 多线程编程,c多线程编程实例,VC多线程编程详解
  • cas 并发,java多线程cas
  • cas 并发,java多线程cas,java并发编程之cas详解
  • android中实现多线程操作的几种方式是什么,android 的多线程 实现方法
  • android中实现多线程操作的几种方式是什么,android 的多线程 实现方法,Android中实现多线程操作的几种方式
  • ,,详解Java多线程tryLock()方法使用
  • python多线程详解,python中的线程和进程
  • python多线程详解,python中的线程和进程,Python线程详解
  • ,,python多线程高级锁condition简单用法示例
  • ,,.NET Windows 多线程thread编程
  • python多线程是不是真正的并发,python的多进程是并发还是并行
  • python 多线程并行处理,python多线程运行
  • python 多线程编程,python多线程有几种实现方法,都是什么
    • 留言与评论（共有 条评论）
       
    验证码：