9.17(day38)线程内容，开启线程的两种方式，子线程共享资源，线程的join方法，线程的其他用法，守护线程

昨日回顾

join会把所有代码变为串行
所以需要进程锁：
到如lock模块
def xxx(lock):
代码
lock.acquire()
处理数据
lock.release()

进程通讯：ipc机制
Queue:队列模式 管道加锁
管道：基于共享内存
put.get(),条件不满足阻塞

如果block=False，不满足直接报错

生产者消费者模型
生产者只需要不停的生产,达到了自己的最大效率,
消费者也只需要不听的消费,也达到了自己的最大效率.
生产者消费者模型,大大提高了生产者的生产效率,也大大提高了消费者的消费效率.

joinablequeue:
计数器：put+1 task_done-1
join() 计数器不为0是阻塞，

线程内容

在操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程，cpu真正的执行单位是线程
在工厂中，每个车间都有房子，而且每个房间默认就有一条流水线，

操作系统：工厂
进程：车间
流程：流水线
cpu:电源

线程：cpu最小的执行单位
进程：资源集合，资源单位
线程运行=运行代码
进程运行=各种资源+线程

右键运行：
申请内存空间，先把解释器丢进去并把代码丢进去(进程做的)，运行代码(线程)

进程线程的区别：
线程：单指代码的执行过程
进程：资源的申请与销毁的过程

进程内存空间彼此隔离
同一个进程下的线程共享资源

进程和线程的创建速度：
进程需要申请资源开辟空间 慢
只是告诉操作系统一个执行方法 快

线程两种开启方式

同进程，可以不写main语句

第一种
from threading import Thread
import time

def task():
    print('start')
    time.sleep(2)
    print('end')

if __name__ == '__main__':   # 可写可不写
    t = Thread(target=task)
    t.start()   # 告诉操作系统开启线程
    print('主线程')

第二种
from threading import Thread
import time
# 进程等待所有子进程结束才会结束
class Myt(Thread):
    def run(self):
        print('start')
        time.sleep(2)
        print('end')

t = Myt()
t.start()
print('主线程')

子进程子线程的开启速度
from threading import Thread
from multiprocessing import Process
import time

def task(name):
    print(f'{name}is run')
    time.sleep(2)
    print(f'{name}is end')

if __name__ == '__main__':
    t = Thread(target=task,args=('子线程',))
    p = Process(target=task,args=('子进程',))
    t.start()
    print('主')

子线程共享资源测试

from threading import Thread
import time
x = 100
def task():
    global x
    x = 50
if __name__ == '__main__':

    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x)

线程的join方法

一个join
from threading import Thread
import time
def task():
    print('start')
    time.sleep(2)
    print('end')

t = Thread(target=task)
t.start()
t.join()   # 等待子线程运行结束
print('主线程')

多个join
from threading import Thread
import time
def task(name,n):
    print(f'{name}start')
    time.sleep(n)
    print(f'{name}end')

t1 = Thread(target=task,args=('线程1',1))
t2 = Thread(target=task,args=('线程2',2))
t3 = Thread(target=task,args=('线程3',3))
start = time.time()
t1.start()
t2.start()
t3.start()
t1.join()   # 等待子线程运行结束
t2.join()
t3.join()
end = time.time()
print(end-start)
print('主线程')

了解进程的join
from multiprocessing import Process
from threading import Thread
import time
def task():
    print('进程开启')
    time.sleep(2)
    print('进程结束')

def task2():
    print('进程开启')
    time.sleep(2)
    print('进程结束')

if __name__ =='__main__':
    p = Process(target=task)
    t = Thread(target=task2)
    t.start()
    p.start()
    print('子进程join开始')
    p.join()   # 主进程的主线程等待子进程运行结束
    print('主')

线程的其他用法

from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('start')
    time.sleep(2)
    print('end')
    print(enumerate())

if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print(t.is_alive())    # 是否存活
    print(t.getName())   # 获取名字
    t.setName('qxq')   # 设置名字
    print(t.getName())
    print(currentThread())   # 当前线程变量
    print(enumerate())   # 三个活跃的线程(不包括启动前，终止后的)
    print(activeCount())   # 活跃进程数量
    print(len(enumerate()))

守护线程

守护的是线程的运行周期
from threading import Thread
import time

def task():
    print('守护线程开始')
    time.sleep(2)
    print('守护线程结束')

def task2():
    print('子线程开始')
    time.sleep(5)
    print('子线程结束')

if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task2)
    t1.daemon = True
    t1.start()
    t2.start()
    print('主')