1.Manager

  1. # ### Manager (list列表,dict字典)进程之间的共享数据(列表或字典等)
  2. from multiprocessing import Process,Manager,Lock
  3.  
  4. def work(data):
  5. '''
  6. #正常写法
  7. lock.acquire()
  8. #data['count'] -= 1
  9. data[0] += 1
  10. lock.release()
  11. '''
  12.  
  13. # 使用with 语法简化上锁解锁操作
  14. with lock:
  15. data[0] +=1
  16.  
  17. if __name__ == '__main__':
  18. m = Manager()
  19. data = m.dict({"count":2000})
  20. date = m.list([1,2,3])
  21. #print(data)
  22.  
  23. lst = []
  24. for i in range(100):
  25. p = Process(target=work,args=(data,))
  26. p.start()
  27. lst.append(p)
  28.  
  29. #确保所有的进程执行完毕,然后再向下运行,打印数据,否则报错
  30. for i in lst:
  31. i.join()
  32.  
  33. print(data) #[101,2,3]
  34. #print(data) #{'count':19900}

2.线程的使用

  1. from threading import Thread
  2. from multiprocessing import Process
  3. import os,time
  4.  
  5. #(1) 一份进程资源中可以包含多个线程
  6. def func(num):
  7. print("当前线程,所归属的进程id",os.getpid(),num)
  8.  
  9. for i in range(10)
  10. #(基于当前这个主进程创建了10个子线程,然后主进程本身就自带一个线程,一共11个)
  11. t = Thread(target=func,args=(i,)) #创建线程跟进程对象用法一样,返回一个线程对象
  12. t.start()
  13.  
  14. #(2) 并发的多进程和多线程,谁的速度更快
  15. def func(num):
  16. print("当前线程,所归属的进程id",os.getpid(),num)
  17.  
  18. if __name__ == '__main__':
  19. #统计1000个线程的运行时间
  20. #记录时间
  21. starttime = time.time()
  22. lst = []
  23. for i in range(1000):
  24. t = Thread(target=func,args=(i,))
  25. t.start()
  26. lst.append(t)
  27. #确保所有线程执行完毕
  28. for i in lst:
  29. i.join()
  30. #结束时间
  31. endtime = time.time()
  32. print('执行的时间是{}'.format(endtime-starttime))
  33.  
  34. #统计1000个进程的运行时间
  35. #记录时间
  36. starttime = time.time()
  37. lst = []
  38. for i in range(1000):
  39. p = Process(target=func,args=(i,))
  40. p.start()
  41. lst.append(p)
  42. #确保所有线程执行完毕
  43. for i in lst:
  44. i.join()
  45. #结束时间
  46. endtime = time.time()
  47. print('执行的时间是{}'.format(endtime-star
  48.  
  49. #(3)多线程共享同一份进程资源
  50. num = 1000
  51. def func():
  52. global num
  53. num -= 1
  54.  
  55. for i in range(1000):
  56. t = Thread(target=func)
  57. t.start()

3.用类定义线程

  1. # ### 用类定义线程
  2. from threading import Thread
  3. import time
  4. from threading import currentThread
  5.  
  6. class MyThread(Thread): #继承父类
  7. def __init__(self,name): #传参初始化的时候需要调用父类的构造方法
  8. super().__init__()
  9. self.name = name
  10.  
  11. def run(self): #一定是run,不能乱写
  12. #time.sleep(1)
  13. print("当前进程正在执行running...",self.name)
  14.  
  15. if __name__ =='__main__':
  16. t = MyThread('机器会爆炸吗')
  17. t.start()
  18. print("主线程执行结束...")
  19.  
  20. # ### 线程的一些相关函数
  21. #线程.is_alive() #检测线程是否仍然存在
  22. #线程.setName() #设置线程名字
  23. #线程.getName() #获取线程名字
  24. #1.currentThread().ident 查看线程id号
  25. #2.enumerate() 返回目前正在运行的线程列表
  26. #3.activeCount() 返回目前正在运行的线程数量
  27.  
  28. def func():
  29. time.sleep(1)
  30.  
  31. if __name__ == '__main__':
  32. t = Thread(target=func)
  33. #print(t)
  34. t.start()
  35. print(t)
  36. print(t.is_alive()) #False
  37. print(t.getName())
  38. t.setName("xboyww")
  39. print(t.getName())
  40.  
  41. #1.currentThread().ident 查看线程id号
  42. def func():
  43. print("子线程id",currentThread().ident,os.getpid())
  44.  
  45. if __name__ == '__main__':
  46. Thread(target=func).start()
  47. print("主线程id",currentThread().ident,os.getpid())
  48.  
  49. #2.enumerate() 返回目前正在运行的线程列表
  50. from threading import enumerate
  51. def func():
  52. print("子线程id",currentThread().ident,os.getpid())
  53. time.sleep(0.5)
  54. if __name__ == '__main__':
  55. for i in range(10):
  56. Thread(target=func).start()
  57. print(enumerate())
  58.  
  59. #3.activeCount() 返回目前正在运行的线程数量
  60. from threading import enumerate
  61. from threading import activeCount
  62. def func():
  63. print("子线程id",currentThread().ident,os.getpid())
  64. time.sleep(0.5)
  65. if __name__ == '__main__':
  66. for i in range(10):
  67. Thread(target=func).start()
  68. lst = enumerate()
  69. #子线程10个,主线程1个 用enumerate也可以返回线程数量
  70. print(lst,len(lst))
  71. #用activeCount()返回线程数量
  72. print( activeCount())

4.守护线程

  1. # ### 守护线程 :等待所有线程全部执行结束,在自己终止,守护所有线程
  2. from threading import Thread
  3. import time
  4. def func1():
  5. while True:
  6. time.sleep(0.5)
  7. print("我是func1")
  8.  
  9. def func2():
  10. print("我是func2 start...")
  11. time.sleep(3)
  12. print("我的func2 end...")
  13.  
  14. t1 = Thread(target=func1)
  15. t2 = Thread(target=func2)
  16.  
  17. #在start调用之前,设置守护线程
  18. t1.setDaemon(True) #守护线程要等待其他所有线程结束后,自己再结束
  19.  
  20. t1.start()
  21. t2.start()#等待这个结束
  22. print("主线程执行结束...") #等待这个结束

5.线程锁保证数据安全

  1. # ### Lock 保证线程数据安全
  2. from threading import Lock,Thread
  3.  
  4. n = 0
  5.  
  6. def func1(lock):
  7. global n
  8. lock.acquire()
  9. for i in range(1000000):
  10.  
  11. n -= 1
  12. lock.release()
  13.  
  14. def func2(lock):
  15. global n
  16. with lock:
  17. for i in range(1000000):
  18.  
  19. n += 1
  20. # func1()
  21. # func2()
  22. # print(n) # 0
  23. if __name__ == '__main__':
  24. lst = []
  25. lock = Lock()
  26. for i in range(10):
  27. t1 = Thread(target=func1,args=(lock,))
  28. t2 = Thread(target=func2,args=(lock,))
  29. t1.start()
  30. t2.start()
  31. lst.append(t1)
  32. lst.append(t2)
  33. #等待所有的子线程执行结束之后,在打印数据
  34. for i in lst:
  35. i.join()
  36. print("主线程执行结束...",n)

6.线程信号量Semaphore

  1. # ### 信号量 Semaphore(线程)
  2. from threading import Semaphore,Thread
  3. import time
  4.  
  5. def func(i,sm):
  6. with sm:
  7. print(i)
  8. time.sleep(3)
  9.  
  10. if __name__ == '__main__':
  11. sm = Semaphore(5)
  12. for i in range(20):
  13. Thread(target=func,args=(i,sm)).start()
  14.  
  15. '''
  16. 在创建线程的时候是异步创建
  17. 在执行任务的时候,因为Semphore加了锁,所以线程之间变成了同步
  18. '''

进程之间共享数据Manager,线程相关使用Thread,用类定义线程,守护线程setDaemon,线程锁Lock,线程信号量Semaphore---day32的更多相关文章

  1. Python 进程之间共享数据

    最近遇到多进程共享数据的问题,到网上查了有几篇博客写的蛮好的,记录下来方便以后查看. 一.Python multiprocessing 跨进程对象共享  在mp库当中,跨进程对象共享有三种方式,第一种 ...

  2. Python 进程之间共享数据(全局变量)

    进程之间共享数据(数值型): import multiprocessing def func(num): num.value=10.78 #子进程改变数值的值,主进程跟着改变 if __name__= ...

  3. VC++共享数据段实现进程之间共享数据

    当我写了一个程序,我希望当这个程序同时运行两遍的时候,两个进程之间能共享一些全局变量,怎么办呢?很简单,使用VC\VC++的共享数据段.; #pragma data_seg()//恢复到正常段继续编程 ...

  4. python进程之间修改数据[Manager]与进程池[Pool]

    #前面的队列Queue和管道Pipe都是仅仅能再进程之间传递数据,但是不能修改数据,今天我们学习的东西就可以在进程之间同时修改一份数据 #Mnager就可以实现 import multiprocess ...

  5. 进程间共享数据Manager

    一.前言 进程间的通信Queue()和Pipe(),可以实现进程间的数据传递.但是要使python进程间共享数据,我们就要使用multiprocessing.Manager. Manager()返回的 ...

  6. day33:进程锁&事件&进程队列&进程间共享数据

    目录 1.锁:Lock 2.信号量:Semaphone 3.事件:Event 4.进程队列:Queue 5.生产者和消费者模型 6.JoinableQueue 7.Manager:进程之间共享数据 锁 ...

  7. 多线程(三) 实现线程范围内模块之间共享数据及线程间数据独立(ThreadLocal)

    ThreadLocal为解决多线程程序的并发问题提供了一种新的思路.JDK 1.2的版本中就提供java.lang.ThreadLocal,使用这个工具类可以很简洁地编写出优美的多线程程序,Threa ...

  8. C# .Net 多进程同步 通信 共享内存 内存映射文件 Memory Mapped 转 VC中进程与进程之间共享内存 .net环境下跨进程、高频率读写数据 使用C#开发Android应用之WebApp 分布式事务之消息补偿解决方案

    C# .Net 多进程同步 通信 共享内存 内存映射文件 Memory Mapped 转 节点通信存在两种模型:共享内存(Shared memory)和消息传递(Messages passing). ...

  9. 多线程(四) 实现线程范围内模块之间共享数据及线程间数据独立(Map集合)

    多个线程访问共享对象和数据的方式 1.如果每个线程执行的代码相同,可以使用同一个Runnable对象,这个Runnable对象中有那个共享数据,例如,买票系统就可以这么做. 2.如果每个线程执行的代码 ...

  10. Python multiprocessing.Manager介绍和实例(进程间共享数据)

    Python中进程间共享数据,处理基本的queue,pipe和value+array外,还提供了更高层次的封装.使用multiprocessing.Manager可以简单地使用这些高级接口. Mana ...

随机推荐

  1. 【转帖】JVM 内存模型与垃圾回收

    文章目录 1. JVM内存模型 1.1. 程序计数器 (线程私有) 1.2. Java 虚拟机栈 (线程私有) 1.3. 本地方法栈 (线程私有) 1.4. Java 堆 (线程共享) 1.5. 方法 ...

  2. Linux下面rsync 实现 完全一致的同步方法

    1. 在某些特殊的linux机器上面, 比如龙芯后者是飞腾服务器,部分工具不太好用, 需要使用x86弄好之后进行同步过去, 这个时候scp 最简单但是网络流量非常大, 不如使用rsync, rsync ...

  3. 手工创建一个带sticky模块的nginx镜像 并且实现容器化负载均衡的方法

    最近想进行容器化运行的nginx反向代理负载均衡服务. 找了一下 dockerhub上面的 nginx 发现里面不包含 sticky模块. 会报错为: nginx: [emerg] unknown d ...

  4. 浅析大促备战过程中出现的fullGc,我们能做什么?

    作者:京东科技 白洋 前言: 背景: 为应对618.双11大促,消费金融侧会根据零售侧大促节奏进行整体系统备战.对核心流量入口承载的系统进行加固优化,排除系统风险,保证大促期间系统稳定. 由于大促期间 ...

  5. vue中render函数使用attrs绑定id、class、style、事件(5)

    1.h函数的三个参数 第一个参数是必须的. 类型:{String | Object | Function} 一个 HTML 标签名.一个组件.一个异步组件.或一个函数式组件. 是要渲染的html标签. ...

  6. 【发现一个问题】使用 fastcgo 导致额外的 `runtime._System` 调用的消耗

    作者:张富春(ahfuzhang),转载时请注明作者和引用链接,谢谢! cnblogs博客 zhihu Github 公众号:一本正经的瞎扯 为了避免 cgo 调用浪费太多资源,因此使用了 fastc ...

  7. Vue基础系列文章11---router基本使用

    1.系统中引入路由js文件,加两个连接,分别到用户管理和用户注册页面 <router-link to="/user">用户列表</router-link> ...

  8. 推荐系统[四]:精排-详解排序算法LTR (Learning to Rank)_ poitwise, pairwise, listwise相关评价指标,超详细知识指南。

    0.前言召回排序流程策略算法简介 推荐可分为以下四个流程,分别是召回.粗排.精排以及重排: 召回是源头,在某种意义上决定着整个推荐的天花板: 粗排是初筛,一般不会上复杂模型: 精排是整个推荐环节的重中 ...

  9. webpack与其常见loader加载器使用方式

    webpack是什么 webpack是前端项目工程化的具体解决方案. 主要功能:提供了友好的前端模块化开发支持,支持代码压缩混淆(去除空格和注释,让文件体积更小),处理浏览器端JS的兼容性(将箭头函数 ...

  10. 在K8S中,节点故障驱逐pod过程时间怎么定义?

    在Kubernetes中,节点故障驱逐Pod的过程涉及多个参数和组件的相互作用.以下是该过程的简要概述: 默认设置:在默认配置下,节点故障时,工作负载的调度周期约为6分钟. 关键参数: node-mo ...