进程之间共享数据Manager,线程相关使用Thread,用类定义线程,守护线程setDaemon,线程锁Lock,线程信号量Semaphore---day32
1.Manager
- # ### Manager (list列表,dict字典)进程之间的共享数据(列表或字典等)
- from multiprocessing import Process,Manager,Lock
- def work(data):
- '''
- #正常写法
- lock.acquire()
- #data['count'] -= 1
- data[0] += 1
- lock.release()
- '''
- # 使用with 语法简化上锁解锁操作
- with lock:
- data[0] +=1
- if __name__ == '__main__':
- m = Manager()
- data = m.dict({"count":2000})
- date = m.list([1,2,3])
- #print(data)
- lst = []
- for i in range(100):
- p = Process(target=work,args=(data,))
- p.start()
- lst.append(p)
- #确保所有的进程执行完毕,然后再向下运行,打印数据,否则报错
- for i in lst:
- i.join()
- print(data) #[101,2,3]
- #print(data) #{'count':19900}
2.线程的使用
- from threading import Thread
- from multiprocessing import Process
- import os,time
- #(1) 一份进程资源中可以包含多个线程
- def func(num):
- print("当前线程,所归属的进程id",os.getpid(),num)
- for i in range(10)
- #(基于当前这个主进程创建了10个子线程,然后主进程本身就自带一个线程,一共11个)
- t = Thread(target=func,args=(i,)) #创建线程跟进程对象用法一样,返回一个线程对象
- t.start()
- #(2) 并发的多进程和多线程,谁的速度更快
- def func(num):
- print("当前线程,所归属的进程id",os.getpid(),num)
- if __name__ == '__main__':
- #统计1000个线程的运行时间
- #记录时间
- starttime = time.time()
- lst = []
- for i in range(1000):
- t = Thread(target=func,args=(i,))
- t.start()
- lst.append(t)
- #确保所有线程执行完毕
- for i in lst:
- i.join()
- #结束时间
- endtime = time.time()
- print('执行的时间是{}'.format(endtime-starttime))
- #统计1000个进程的运行时间
- #记录时间
- starttime = time.time()
- lst = []
- for i in range(1000):
- p = Process(target=func,args=(i,))
- p.start()
- lst.append(p)
- #确保所有线程执行完毕
- for i in lst:
- i.join()
- #结束时间
- endtime = time.time()
- print('执行的时间是{}'.format(endtime-star
- #(3)多线程共享同一份进程资源
- num = 1000
- def func():
- global num
- num -= 1
- for i in range(1000):
- t = Thread(target=func)
- t.start()
3.用类定义线程
- # ### 用类定义线程
- from threading import Thread
- import time
- from threading import currentThread
- class MyThread(Thread): #继承父类
- def __init__(self,name): #传参初始化的时候需要调用父类的构造方法
- super().__init__()
- self.name = name
- def run(self): #一定是run,不能乱写
- #time.sleep(1)
- print("当前进程正在执行running...",self.name)
- if __name__ =='__main__':
- t = MyThread('机器会爆炸吗')
- t.start()
- print("主线程执行结束...")
- # ### 线程的一些相关函数
- #线程.is_alive() #检测线程是否仍然存在
- #线程.setName() #设置线程名字
- #线程.getName() #获取线程名字
- #1.currentThread().ident 查看线程id号
- #2.enumerate() 返回目前正在运行的线程列表
- #3.activeCount() 返回目前正在运行的线程数量
- def func():
- time.sleep(1)
- if __name__ == '__main__':
- t = Thread(target=func)
- #print(t)
- t.start()
- print(t)
- print(t.is_alive()) #False
- print(t.getName())
- t.setName("xboyww")
- print(t.getName())
- #1.currentThread().ident 查看线程id号
- def func():
- print("子线程id",currentThread().ident,os.getpid())
- if __name__ == '__main__':
- Thread(target=func).start()
- print("主线程id",currentThread().ident,os.getpid())
- #2.enumerate() 返回目前正在运行的线程列表
- from threading import enumerate
- def func():
- print("子线程id",currentThread().ident,os.getpid())
- time.sleep(0.5)
- if __name__ == '__main__':
- for i in range(10):
- Thread(target=func).start()
- print(enumerate())
- #3.activeCount() 返回目前正在运行的线程数量
- from threading import enumerate
- from threading import activeCount
- def func():
- print("子线程id",currentThread().ident,os.getpid())
- time.sleep(0.5)
- if __name__ == '__main__':
- for i in range(10):
- Thread(target=func).start()
- lst = enumerate()
- #子线程10个,主线程1个 用enumerate也可以返回线程数量
- print(lst,len(lst))
- #用activeCount()返回线程数量
- print( activeCount())
4.守护线程
- # ### 守护线程 :等待所有线程全部执行结束,在自己终止,守护所有线程
- from threading import Thread
- import time
- def func1():
- while True:
- time.sleep(0.5)
- print("我是func1")
- def func2():
- print("我是func2 start...")
- time.sleep(3)
- print("我的func2 end...")
- t1 = Thread(target=func1)
- t2 = Thread(target=func2)
- #在start调用之前,设置守护线程
- t1.setDaemon(True) #守护线程要等待其他所有线程结束后,自己再结束
- t1.start()
- t2.start()#等待这个结束
- print("主线程执行结束...") #等待这个结束
5.线程锁保证数据安全
- # ### Lock 保证线程数据安全
- from threading import Lock,Thread
- n = 0
- def func1(lock):
- global n
- lock.acquire()
- for i in range(1000000):
- n -= 1
- lock.release()
- def func2(lock):
- global n
- with lock:
- for i in range(1000000):
- n += 1
- # func1()
- # func2()
- # print(n) # 0
- if __name__ == '__main__':
- lst = []
- lock = Lock()
- for i in range(10):
- t1 = Thread(target=func1,args=(lock,))
- t2 = Thread(target=func2,args=(lock,))
- t1.start()
- t2.start()
- lst.append(t1)
- lst.append(t2)
- #等待所有的子线程执行结束之后,在打印数据
- for i in lst:
- i.join()
- print("主线程执行结束...",n)
6.线程信号量Semaphore
- # ### 信号量 Semaphore(线程)
- from threading import Semaphore,Thread
- import time
- def func(i,sm):
- with sm:
- print(i)
- time.sleep(3)
- if __name__ == '__main__':
- sm = Semaphore(5)
- for i in range(20):
- Thread(target=func,args=(i,sm)).start()
- '''
- 在创建线程的时候是异步创建
- 在执行任务的时候,因为Semphore加了锁,所以线程之间变成了同步
- '''
进程之间共享数据Manager,线程相关使用Thread,用类定义线程,守护线程setDaemon,线程锁Lock,线程信号量Semaphore---day32的更多相关文章
- Python 进程之间共享数据
最近遇到多进程共享数据的问题,到网上查了有几篇博客写的蛮好的,记录下来方便以后查看. 一.Python multiprocessing 跨进程对象共享 在mp库当中,跨进程对象共享有三种方式,第一种 ...
- Python 进程之间共享数据(全局变量)
进程之间共享数据(数值型): import multiprocessing def func(num): num.value=10.78 #子进程改变数值的值,主进程跟着改变 if __name__= ...
- VC++共享数据段实现进程之间共享数据
当我写了一个程序,我希望当这个程序同时运行两遍的时候,两个进程之间能共享一些全局变量,怎么办呢?很简单,使用VC\VC++的共享数据段.; #pragma data_seg()//恢复到正常段继续编程 ...
- python进程之间修改数据[Manager]与进程池[Pool]
#前面的队列Queue和管道Pipe都是仅仅能再进程之间传递数据,但是不能修改数据,今天我们学习的东西就可以在进程之间同时修改一份数据 #Mnager就可以实现 import multiprocess ...
- 进程间共享数据Manager
一.前言 进程间的通信Queue()和Pipe(),可以实现进程间的数据传递.但是要使python进程间共享数据,我们就要使用multiprocessing.Manager. Manager()返回的 ...
- day33:进程锁&事件&进程队列&进程间共享数据
目录 1.锁:Lock 2.信号量:Semaphone 3.事件:Event 4.进程队列:Queue 5.生产者和消费者模型 6.JoinableQueue 7.Manager:进程之间共享数据 锁 ...
- 多线程(三) 实现线程范围内模块之间共享数据及线程间数据独立(ThreadLocal)
ThreadLocal为解决多线程程序的并发问题提供了一种新的思路.JDK 1.2的版本中就提供java.lang.ThreadLocal,使用这个工具类可以很简洁地编写出优美的多线程程序,Threa ...
- C# .Net 多进程同步 通信 共享内存 内存映射文件 Memory Mapped 转 VC中进程与进程之间共享内存 .net环境下跨进程、高频率读写数据 使用C#开发Android应用之WebApp 分布式事务之消息补偿解决方案
C# .Net 多进程同步 通信 共享内存 内存映射文件 Memory Mapped 转 节点通信存在两种模型:共享内存(Shared memory)和消息传递(Messages passing). ...
- 多线程(四) 实现线程范围内模块之间共享数据及线程间数据独立(Map集合)
多个线程访问共享对象和数据的方式 1.如果每个线程执行的代码相同,可以使用同一个Runnable对象,这个Runnable对象中有那个共享数据,例如,买票系统就可以这么做. 2.如果每个线程执行的代码 ...
- Python multiprocessing.Manager介绍和实例(进程间共享数据)
Python中进程间共享数据,处理基本的queue,pipe和value+array外,还提供了更高层次的封装.使用multiprocessing.Manager可以简单地使用这些高级接口. Mana ...
随机推荐
- 【转帖】JVM 内存模型与垃圾回收
文章目录 1. JVM内存模型 1.1. 程序计数器 (线程私有) 1.2. Java 虚拟机栈 (线程私有) 1.3. 本地方法栈 (线程私有) 1.4. Java 堆 (线程共享) 1.5. 方法 ...
- Linux下面rsync 实现 完全一致的同步方法
1. 在某些特殊的linux机器上面, 比如龙芯后者是飞腾服务器,部分工具不太好用, 需要使用x86弄好之后进行同步过去, 这个时候scp 最简单但是网络流量非常大, 不如使用rsync, rsync ...
- 手工创建一个带sticky模块的nginx镜像 并且实现容器化负载均衡的方法
最近想进行容器化运行的nginx反向代理负载均衡服务. 找了一下 dockerhub上面的 nginx 发现里面不包含 sticky模块. 会报错为: nginx: [emerg] unknown d ...
- 浅析大促备战过程中出现的fullGc,我们能做什么?
作者:京东科技 白洋 前言: 背景: 为应对618.双11大促,消费金融侧会根据零售侧大促节奏进行整体系统备战.对核心流量入口承载的系统进行加固优化,排除系统风险,保证大促期间系统稳定. 由于大促期间 ...
- vue中render函数使用attrs绑定id、class、style、事件(5)
1.h函数的三个参数 第一个参数是必须的. 类型:{String | Object | Function} 一个 HTML 标签名.一个组件.一个异步组件.或一个函数式组件. 是要渲染的html标签. ...
- 【发现一个问题】使用 fastcgo 导致额外的 `runtime._System` 调用的消耗
作者:张富春(ahfuzhang),转载时请注明作者和引用链接,谢谢! cnblogs博客 zhihu Github 公众号:一本正经的瞎扯 为了避免 cgo 调用浪费太多资源,因此使用了 fastc ...
- Vue基础系列文章11---router基本使用
1.系统中引入路由js文件,加两个连接,分别到用户管理和用户注册页面 <router-link to="/user">用户列表</router-link> ...
- 推荐系统[四]:精排-详解排序算法LTR (Learning to Rank)_ poitwise, pairwise, listwise相关评价指标,超详细知识指南。
0.前言召回排序流程策略算法简介 推荐可分为以下四个流程,分别是召回.粗排.精排以及重排: 召回是源头,在某种意义上决定着整个推荐的天花板: 粗排是初筛,一般不会上复杂模型: 精排是整个推荐环节的重中 ...
- webpack与其常见loader加载器使用方式
webpack是什么 webpack是前端项目工程化的具体解决方案. 主要功能:提供了友好的前端模块化开发支持,支持代码压缩混淆(去除空格和注释,让文件体积更小),处理浏览器端JS的兼容性(将箭头函数 ...
- 在K8S中,节点故障驱逐pod过程时间怎么定义?
在Kubernetes中,节点故障驱逐Pod的过程涉及多个参数和组件的相互作用.以下是该过程的简要概述: 默认设置:在默认配置下,节点故障时,工作负载的调度周期约为6分钟. 关键参数: node-mo ...