PYTHON2.day07

野性酷女 2022-01-09 04:25 254阅读 0赞

前情回顾

1. multiprocessing模块 创建进程  
     
    基本创建进程： Process(target,args,kwargs,name)  
                   start()  
           join(\[timeout\])  
     
    进程对象属性：p.name  p.pid  p.daemon  p.is\_alive()

自定义进程类：1. 继承Process，重写\_\_init\_\_  
                  2. 重写run方法

进程池： 大量进程事件需要较多进程处理，  
             此时进程池可以避免进程频繁创建销毁带来的系统消耗。

Pool()  创建进程池对象  
         apply\_async()  将事件使用进程池执行,async(异步)  
         close()  关闭进程池，不能再添加新的事件了  
         join()  回收进程池  
         map()  使用迭代对象为指定函数传参后，加入进程池

2. 进程间通信  
   
    【1】管道  ： Pipe()   fd.recv()  fd.send()

【2】消息队列：Queue()  q.get()获取消息  q.put() 存入消息  
                   q.full() q.empty() q.qsize()  q.close()

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 import os
      2 from multiprocessing import Process
      3 
      4 filename = './he.jpg'
      5 
      6 #获取文件大小
      7 size = os.path.getsize(filename)
      8 
      9 #复制上半部分
     10 def top():
     11     f = open(filename,'rb')
     12     n = size // 2
     13     fw = open("half_top.jpg",'wb')
     14     while True:
     15         if n < 1024:
     16             data = f.read(n)
     17             fw.write(data)
     18             break
     19         data = f.read(1024)
     20         fw.write(data)
     21         n -=1024
     22     f.close()
     23     fw.close()
     24 
     25 #复制下半部分
     26 def boot():
     27     f = open(filename,'rb')
     28     fw = open('half_bottom.jpg','wb')
     29     f.seek(size//2,0)
     30 
     31     while True:
     32         data = f.read(1024)
     33         if not data:
     34             break
     35         fw.write(data)
     36     f.close()
     37     fw.close()
     38 
     39 t = Process(target = top)
     40 b = Process(target = boot)
     41 t.start()
     42 b.start()
     43 t.join()
     44 b.join()

cope\_file.py

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
 一.进程间通信(续)  
1.共享内存  
   【1】通信原理：在内存中开辟一块空间，进程可以写入内容和读取内容完成通信，  
                  但是每次写入内容会覆盖之前的内容  
   【2】实现方法：  
                 from multiprocessing import Value,Array  
                  
                 obj = Value(ctype,data)  
                 功能：开辟共享内存  
                 参数：ctype 表示共享内存空间类型'i'整  'f'浮点  'c'字符  
                       data 共享内存空间初始数据  
                 返回值：共享内存对象  
                  
                 obj.value  对该属性的修改或查看即对共享内存的读写  
                  
                 obj = Array(ctype,data)  
                 功能：开辟共享内存空间  
                 参数：ctype 表示共享内存数据类型  
                       data  整数      则表示开辟空间的大小，  
                             其他数据  开辟空间存放的初始化数据  
                 返回值：共享内存对象  
                  
                 Array共享内存读写：通过遍历obj可以得到的每个值，直接可以通过索引号修改任意值。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from multiprocessing import Process,Value
      2 import time
      3 import random
      4 
      5 #创共享内存
      6 money = Value('i',5000)
      7 
      8 #操作共享内存
      9 def man():
     10     for i in range(30):
     11         time.sleep(0.2)
     12         money.value += random.randint(1,1000)
     13 
     14 def girl():
     15     for i in range(30):
     16         time.sleep(0.16)
     17         money.value -= random.randint(100,900)
     18 
     19 m = Process(target=man)
     20 g = Process(target=girl)
     21 m.start()
     22 g.start()
     23 m.join()
     24 g.join()
     25 
     26 print("一月余额：",money.value)

value.py

[![1value][]][1value 1]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from multiprocessing import Process,Array
      2 import time
      3 
      4 #创建共享内存
      5 #shm = Array('i',[1,2,3,4,5])
      6 
      7 #创建共享内存，指定开辟空间大小
      8 # shm =Array('i',6)
      9 
     10 
     11 #存如字符串
     12 shm = Array('c',b'Hello')
     13 
     14 
     15 def fun():
     16     for i in shm:
     17         print(i)
     18     # shm[2]=3000
     19     shm[0] = b'h'
     20 
     21 p = Process(target = fun)
     22 p.start()
     23 p.join()
     24 
     25 for i in shm:
     26     print(i,end=" ")
     27 print(shm.value)#打印字符串

array\_2.py

[![2array][]][2array 1]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from multiprocessing import Process,Array
      2 import time
      3 
      4 #创建共享内存
      5 #shm = Array('i',[1,2,3,4,5])
      6 
      7 #创建共享内存，指定开辟空间大小
      8 # shm =Array('i',6)
      9 
     10 
     11 #存如字符串
     12 shm = Array('c',b'Hello')
     13 
     14 
     15 def fun():
     16     for i in shm:
     17         print(i)
     18     # shm[2]=3000
     19     shm[0] = b'h'
     20 
     21 p = Process(target = fun)
     22 p.start()
     23 p.join()
     24 
     25 for i in shm:
     26     print(i,end=" ")
     27 print(shm.value)#打印字符串

array\_3.py

[![2array\_3][2array_3]][2array_3_2array_3]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from multiprocessing import Process,Array
      2 import time
      3 
      4 
      5 #创建共享内存，指定开辟空间大小
      6 shm =Array('i',6)
      7 
      8 
      9 
     10 def fun():
     11     for i in shm:
     12         print(i)
     13     shm[2]=3000
     14 
     15 
     16 p = Process(target = fun)
     17 p.start()
     18 p.join()
     19 
     20 for i in shm:
     21     print(i,end=" ")
     22 print()

Array.py

**2.信号量(信号灯集)**  
   \[1\]通信原理：给定一个数量对多个进程可见。多个进程都可以操作该数量增减，并根据数量决定自己的行为  
   \[2\]实现方法  
             from multiprocessing import Semaphore  
              
             sem = Semaphore(num)  
             功能：创建信号量对象  
             参数：信号量的初始值  
             返回值：信号量对象  
             sem.acqire() 将信号量减1 当信号量为0时阻塞  
             sem.release() 将信号量+1  
             sem.get\_value()获取信号量数量

补充：当在父进程中创建套接字，进程间通信对象，文件对象，子进程从父进程获取这些对象时，那么对对象的操作  
       会有属性的相互关联影响。如果在各自进程中单独创建这些对象，则各自互不影响。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from multiprocessing import Semaphore,Process
      2 from time import sleep
      3 import os
      4 #创建信号量
      5 sem = Semaphore(3)
      6 
      7 def fun():
      8     print("%d 想执行事件"%os.getpid())
      9     #想执行事件必须得到信号资源
     10     sem.acquire()
     11     print("%s 抢到了一个信号量，可以执行操作"%os.getpid())
     12     sleep(3)
     13     print("%d执行完事件再增加信号量"%os.getgid())
     14     sem.release()
     15 jobs=[]
     16 for i in range(5):
     17     p = Process(target = fun)
     18     jobs.append(p)
     19     p.start()
     20 
     21 for i in jobs:
     22     i.join()
     23 
     24 print(sem.get_value())

3sem.py

[![3][]][3 1]  
二.线程编程(Thread)  
     1.什么是线程  
       【1】线程被称为轻量级的进程  
       【2】线程也可以使用计算机多核资源，是多任务编程方式  
       【3】线程是系统分配内核的最小单元  
       【4】线程可以理解为进程的分支任务  
         
         
     2.线程特征  
       【1】一个进程中可以包含多个线程  
       【2】线程也是一个运行行为，消耗计算机资源  
       【3】一个进程中的所有线程共享这个进程的资源  
       【4】多个线程之间的运行互不影响各自运行  
       【5】线程的创建和销毁消耗资源远小于进程  
       【6】各个线程有自己的ID等特征  
        
     3.创建线程threading模块  
         【1】创建线程对象  
             from threading import Thread  
             t = Thread()  
             功能：创建线程对象  
             参数：target 绑定线程对象  
                   args   元组 给线程函数位置传参  
                   kwargs 字典 给线程函数键值传参  
         【2】启动线程  
             t.start()  
         【3】回收线程  
             t.join(\[timeout\])  
              
     4.线程对象属性：  
         t.name 线程名称  
         t.setName()   设置线程名称  
         t.getName()   获取线程名称  
          
         t.is\_alive()  查看线程是否在生命周期  
          
         t.daemon 设置主线程和分支线程的  关系  
         t.setDaemon() 设置daemon属性值  
         t.isDaemon()  查看daemon属性值  
         \*daemon为True时主线程退出分支线程也退出。  
                要在start前设置，通常不和join一起使用

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 import threading
      2 from time import sleep
      3 import os
      4 
      5 a=1
      6 #线程函数
      7 def music():
      8     global a
      9     print("a=",a)
     10     for i in range(5):
     11         sleep(2)
     12         print("播放鱼",os.getpid())
     13         a = 10000
     14 
     15 #创建线程对象
     16 t = threading.Thread(target = music)
     17 t.start()
     18 
     19 #主线程运行任务
     20 for i in range(3):
     21     sleep(3)
     22     print("《大哥》",os.getpid())
     23 t.join()
     24 print("Main thread a:",a)

thread\_1.py

[![4.1][]][4.1 1]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from threading import Thread
      2 from time import sleep
      3 
      4 #含有参数的线程函数
      5 def fun(sec,name):
      6     print("线程函数传参")
      7     sleep(sec)
      8     print("%s 线程执行完毕"%name)
      9 
     10 #创建多个线程
     11 threads = []
     12 for i in range(5):
     13     t = Thread(target = fun,args=(2,),kwargs={'name':'T%d'%i})
     14     threads.append(t)
     15     t.start()
     16 
     17 for i in threads:
     18     i.join()

thread\_2.py

[![4thread2][]][4thread2 1]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from threading import Thread
      2 from time import sleep
      3 
      4 def fun():
      5     sleep(3)
      6     print("线程属性测试")
      7 
      8 # t = Thread(target = fun)
      9 t = Thread(target = fun,name = 'Tarena')
     10 
     11 
     12 
     13 #线程名称
     14 t.setName('Tedu')#设置完会覆盖之间前的名称
     15 print('Thread name:',t.name)
     16 print("Thread name:",t.getName())
     17 
     18 
     19 #设置daemon为True
     20 t.setDaemon(True)
     21 t.start()
     22 
     23 #查看线程的生命周期
     24 print("alive:",t.is_alive())
     25 t.join()

thread\_attr.py

[![4thread\_attr][4thread_attr]][4thread_attr_4thread_attr]  
     5.自定义线程类：  
         【1】创建步骤  
             1. 继承Thread类  
             2.重写\_\_init\_\_方法添加自己的属性，使用super加载父类属性  
             3.重写run方法  
         【2】使用方法  
             1.实例化对象  
             2.调用start自动执行run方法  
             3.调用join回收线程

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from threading import Thread
      2 from time import sleep,ctime
      3 
      4 class MyThread(Thread):
      5     def __init__(self,target=None,args=(),kwargs={},name='Tedu'):
      6         super().__init__()
      7         self.target = target
      8         self.args = args
      9         self.kwargs = kwargs
     10         self.name = name
     11 
     12     def run(self):
     13         self.target(*self.args,**self.kwargs)
     14 def player(sec,song):
     15     for i in range(2):
     16         print("playing %s:%s"%(song,ctime()))
     17         sleep(sec)
     18 
     19 t = MyThread(target = player,args=(3,),kwargs={'song':'凉凉'},name='happy')
     20 
     21 t.start()
     22 t.join()

mythread.py

[![5mythread][]][5mythread 1]        
三.线程通信  
     【1】通信方法:线程间使用全局变量间进行通信  
     【2】共享资源争夺  
             1.共享资源：多个进程或者线程都可以操作的资源成为公共资源，  
                         对共享资源的操作代码段称为临界区。  
             2.影响:对共享资源的而无需操作可能会代来数据的混乱，或者操作错误。  
                    此时往往需要同步互斥机制协调操作顺序。  
     【3】同步互斥机制  
          同步：同步是一种协作关系，为完成操作，多进程或者线程间形成一种协调，  
                按照必要的步骤有序执行操作。  
          互斥：是一种制约关系资源，当一个进程或者线程占有资源是会进行加锁处理，  
                此时其他进程线程就无法操作该资源，直到解锁后才能操作。  
              
     【4】线程同步互斥方法  
         1.线程Event  
             from threading import Event  
             e = Event() 创建线程event对象  
             e.wait(\[timeout\]) 阻塞等待e被set  
             e.set()  设置e，使wait结束阻塞  
             e.clear() 使e回到未被设置的状态  
             e.is\_set()查看当前e是否被设置

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 	from threading import Event
      2 
      3 #创建事件对象
      4 e = Event()
      5 
      6 e.set()#设置e
      7 e.clear()#清楚set状态
      8 print(e.is_set())#查看是否被设置
      9 e.wait(3)#超时时间
     10 print("-------------")

event\_test.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from threading import Thread,Event
      2 from time import sleep
      3 
      4 s = None#全局变量，用于通信
      5 e = Event()
      6 
      7 def foo():
      8     sleep(0.1)
      9     print("Foo 前来拜山头")
     10     global s
     11     s = "天王盖地虎"
     12     e.set()#设置e
     13 
     14 f = Thread(target = foo)
     15 f.start()
     16 
     17 #主线程验证口令
     18 print("说对口令为自己人")
     19 e.wait()#添加阻塞
     20 if s == '天王盖地虎':
     21     print("是自己人")
     22 else:
     23     print("不是自己人")
     24 
     25 f.join()

theard\_event.py

2.线程锁 Lock  
             from threading import Lock  
             lock = Lock()\#创建锁对象  
             lock.acqire()\#上锁 如果lock已经上锁在调用会阻塞  
             lock.release()\#解锁  
              
             with lock:   上锁  
                ...  
                ...  
              
                       with代码块结束自动解锁

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 from threading import Thread,Lock
      2 
      3 a = b = 0
      4 lock = Lock()#锁对象
      5 #一个线程
      6 def value():
      7     while True:
      8         lock.acquire()
      9         if a!=b:
     10             print("a=%d,b=%d"%(a,b))
     11         lock.release()
     12 
     13 t = Thread(target=value)
     14 t.start()
     15 #另一个线程
     16 while True:
     17     while True:
     18         with lock:
     19             a +=1
     20             b +=1
     21 
     22 t.join()

theard\_lock.py

作业：1.对比进程线程的特点区别  
       2.做单进程，    多进程,           多线程的效率测试   
           执行10遍    创建10个进程      创建10个线程  
                       每个执行一遍      每个执行一遍

转载于:https://www.cnblogs.com/shengjia/p/10416284.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220109/c272dfc48dd04f1ca196509333bb4eba.png
[1value]: /images/20220109/eccb23be3af2429e9f3796d9bcd9aefa.png
[1value 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083855799-602879849.png
[2array]: /images/20220109/9c699fb1a499477ebb631ee17702ae68.png
[2array 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083856772-1906608667.png
[2array_3]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083858417-47222302.png
[2array_3_2array_3]: /images/20220109/4a0d3e2795ea4bf4b75579298801dc67.png
[3]: /images/20220109/3a7e9c7cd43f492089211f9c4f071abf.png
[3 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083900037-1787224698.png
[4.1]: /images/20220109/d4ab384df38a48d68103a9e1791c8941.png
[4.1 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083902414-974285590.png
[4thread2]: /images/20220109/0ca4d3b7b82c45f4814c7c6c79b2aa29.png
[4thread2 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083903698-1782687410.png
[4thread_attr]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083905895-13061428.png
[4thread_attr_4thread_attr]: /images/20220109/7e6600f3f9e34aa59196fabe9ccec198.png
[5mythread]: /images/20220109/610ca2fa9f894b20b33aa3ffab63577e.png
[5mythread 1]: https://img2018.cnblogs.com/blog/1448556/201902/1448556-20190222083906413-1961148240.png

发表评论取消回复

表情：

评论列表（有 0 条评论，254人围观）

还没有评论，来说两句吧...

相关阅读

相关 day07-方法

1. 方法概述 1.1 方法的概念方法（method）是程序中最小的执行单元注意：方法必须先创建才可以使用，该过程成为方法定义

￡神魔★判官ぃ/ 2024年03月02日 08:48/ 0 赞/ 78 阅读

相关铁乐学Python_day07_集合

1、【List补充】在循环一个列表时，最好不要使用元素和索引进行删除操作，一旦删除，索引会随之改变，容易出错。如果想不出错，可以采用倒着删除的方法，因为倒着删除进

偏执的太偏执、/ 2022年05月28日 02:38/ 0 赞/ 224 阅读

相关 python学习——day07

本文参与「少数派读书笔记征文活动」[https://sspai.com/post/45653][https_sspai.com_post_45653] 参考文章：[http:

迈不过友情╰/ 2022年05月18日 02:52/ 0 赞/ 375 阅读

相关 day07

01 1 package com.tedu.demo; 2 3 public class ArrayMethodTest_01 { 4

矫情吗；*/ 2022年04月24日 02:04/ 0 赞/ 213 阅读

相关 PYTHON2.day07

前情回顾 1. multiprocessing模块创建进程基本创建进程： Process(target,args,kwargs,name)

野性酷女/ 2022年01月09日 04:25/ 0 赞/ 255 阅读

相关 python day07

数据类型之间的相互转换 1、字符串转换成数字类型判断哪些可以转换成数字型可以参考下面例题：　判断实现将所有能转换为数字类型的字符串都转换为对应类型的数字

以你之姓@/ 2021年12月16日 11:53/ 0 赞/ 284 阅读

相关 Day07

变量的访问原则和this关键字 1，变量的访问原则；在方法中，使用一个变量时，会去找这个变量的声明和定义，寻找原则是，就近原则 2，就近原则：在寻找变量定义

末蓝、/ 2021年12月10日 21:25/ 0 赞/ 275 阅读

相关 Python day2

1. 布尔运算符可以直接当做1 0 来运算：例如： >>>a=True >>>b=3

怼烎@/ 2021年12月01日 15:18/ 0 赞/ 288 阅读

相关 day07

数字内置方法整形 1. 作用描述年龄,id号 2. 定义方式 x = 10 x = int('10') x

小鱼儿/ 2021年10月29日 13:00/ 0 赞/ 309 阅读

相关 Python_day2

homework： ''' 作业三用函数实现登录功能 1、让用户输入用户名与密码 2、校验用户名是否存在 3、用户名存在后检

红太狼/ 2021年10月18日 20:14/ 0 赞/ 292 阅读