进程之间共享数据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加了锁，所以线程之间变成了同步
'''