PYTHON2.day07

前情回顾

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()

import os
from multiprocessing import Process

filename = './he.jpg'

#获取文件大小
size = os.path.getsize(filename)

#复制上半部分
def top():
    f = open(filename,'rb')
    n = size // 2
    fw = open("half_top.jpg",'wb')
    while True:
        if n < 1024:
            data = f.read(n)
            fw.write(data)
            break
        data = f.read(1024)
        fw.write(data)
        n -=1024
    f.close()
    fw.close()

#复制下半部分
def boot():
    f = open(filename,'rb')
    fw = open('half_bottom.jpg','wb')
    f.seek(size//2,0)

    while True:
        data = f.read(1024)
        if not data:
            break
        fw.write(data)
    f.close()
    fw.close()

t = Process(target = top)
b = Process(target = boot)
t.start()
b.start()
t.join()
b.join()

************************************************************************************************************
一.进程间通信(续)
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可以得到的每个值，直接可以通过索引号修改任意值。
     

from multiprocessing import Process,Value
import time
import random

#创共享内存
money = Value('i',5000)

#操作共享内存
def man():
    for i in range(30):
        time.sleep(0.2)
        money.value += random.randint(1,1000)

def girl():
    for i in range(30):
        time.sleep(0.16)
        money.value -= random.randint(100,900)

m = Process(target=man)
g = Process(target=girl)
m.start()
g.start()
m.join()
g.join()

print("一月余额：",money.value)

     

from multiprocessing import Process,Array
import time

#创建共享内存
#shm = Array('i',[1,2,3,4,5])

#创建共享内存，指定开辟空间大小
# shm =Array('i',6)


#存如字符串
shm = Array('c',b'Hello')


def fun():
    for i in shm:
        print(i)
    # shm[2]=3000
    shm[0] = b'h'

p = Process(target = fun)
p.start()
p.join()

for i in shm:
    print(i,end=" ")
print(shm.value)#打印字符串

    

from multiprocessing import Process,Array
import time

#创建共享内存
#shm = Array('i',[1,2,3,4,5])

#创建共享内存，指定开辟空间大小
# shm =Array('i',6)


#存如字符串
shm = Array('c',b'Hello')


def fun():
    for i in shm:
        print(i)
    # shm[2]=3000
    shm[0] = b'h'

p = Process(target = fun)
p.start()
p.join()

for i in shm:
    print(i,end=" ")
print(shm.value)#打印字符串

from multiprocessing import Process,Array
import time


#创建共享内存，指定开辟空间大小
shm =Array('i',6)



def fun():
    for i in shm:
        print(i)
    shm[2]=3000


p = Process(target = fun)
p.start()
p.join()

for i in shm:
    print(i,end=" ")
print()

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

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

from multiprocessing import Semaphore,Process
from time import sleep
import os
#创建信号量
sem = Semaphore(3)

def fun():
    print("%d 想执行事件"%os.getpid())
    #想执行事件必须得到信号资源
    sem.acquire()
    print("%s 抢到了一个信号量，可以执行操作"%os.getpid())
    sleep(3)
    print("%d执行完事件再增加信号量"%os.getgid())
    sem.release()
jobs=[]
for i in range(5):
    p = Process(target = fun)
    jobs.append(p)
    p.start()

for i in jobs:
    i.join()

print(sem.get_value())

二.线程编程(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一起使用

import threading
from time import sleep
import os

a=1
#线程函数
def music():
    global a
    print("a=",a)
    for i in range(5):
        sleep(2)
        print("播放鱼",os.getpid())
        a = 10000

#创建线程对象
t = threading.Thread(target = music)
t.start()

#主线程运行任务
for i in range(3):
    sleep(3)
    print("《大哥》",os.getpid())
t.join()
print("Main thread a:",a)

from threading import Thread
from time import sleep

#含有参数的线程函数
def fun(sec,name):
    print("线程函数传参")
    sleep(sec)
    print("%s 线程执行完毕"%name)

#创建多个线程
threads = []
for i in range(5):
    t = Thread(target = fun,args=(2,),kwargs={'name':'T%d'%i})
    threads.append(t)
    t.start()

for i in threads:
    i.join()

from threading import Thread
from time import sleep

def fun():
    sleep(3)
    print("线程属性测试")

# t = Thread(target = fun)
t = Thread(target = fun,name = 'Tarena')



#线程名称
t.setName('Tedu')#设置完会覆盖之间前的名称
print('Thread name:',t.name)
print("Thread name:",t.getName())


#设置daemon为True
t.setDaemon(True)
t.start()

#查看线程的生命周期
print("alive:",t.is_alive())
t.join()

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

from threading import Thread
from time import sleep,ctime

class MyThread(Thread):
    def __init__(self,target=None,args=(),kwargs={},name='Tedu'):
        super().__init__()
        self.target = target
        self.args = args
        self.kwargs = kwargs
        self.name = name

    def run(self):
        self.target(*self.args,**self.kwargs)
def player(sec,song):
    for i in range(2):
        print("playing %s:%s"%(song,ctime()))
        sleep(sec)

t = MyThread(target = player,args=(3,),kwargs={'song':'凉凉'},name='happy')

t.start()
t.join()

      
三.线程通信
     【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是否被设置

	from threading import Event

#创建事件对象
e = Event()

e.set()#设置e
e.clear()#清楚set状态
print(e.is_set())#查看是否被设置
e.wait(3)#超时时间
print("-------------")

from threading import Thread,Event
from time import sleep

s = None#全局变量，用于通信
e = Event()

def foo():
    sleep(0.1)
    print("Foo 前来拜山头")
    global s
    s = "天王盖地虎"
    e.set()#设置e

f = Thread(target = foo)
f.start()

#主线程验证口令
print("说对口令为自己人")
e.wait()#添加阻塞
if s == '天王盖地虎':
    print("是自己人")
else:
    print("不是自己人")

f.join()

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

from threading import Thread,Lock

a = b = 0
lock = Lock()#锁对象
#一个线程
def value():
    while True:
        lock.acquire()
        if a!=b:
            print("a=%d,b=%d"%(a,b))
        lock.release()

t = Thread(target=value)
t.start()
#另一个线程
while True:
    while True:
        with lock:
            a +=1
            b +=1

t.join()

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