day 35 线程

内容回顾

# 互斥锁
    #在同一个进程中连续锁多次

#进程的数据共享
    #进程之间可以共享数据
    #提供共享数据的类是Manager
    #但是它提供的list|dict 这些数据类型
        #针对+= -= *= -=
    #需要加锁保证安全

# 进程之间的通信
#     ipc:
        #queue
        #管道

    #机制也可以数据通信
    #manager
    #lock   #acquire  acquire 还有一块空间 有锁的状态
    #Process    #开启时

# 进程锁  线程锁   #一个共享  一个锁就得通信  线程锁不锁得住 进程

# 线程
    #概念
        #进程和线程的区别
            #进程  开销大  数据隔离
                #是计算机中最小的资源分配单位
            #线程  轻量级  共享数据
                #是计算机中能被cpu调度的最小单位
        #正常的线程是什么
            #能同时被多个cpu执行

        #Cpython解释器下的线程（解释器里有 锁只一个进程一个时刻会用）
            #GIL锁
            #全局解释器锁
            #是CPython解释其中的
            #会导致同一个时刻只能有一个线程

    #代码 threading 模块
        #Thread 类
            #开启线程
            #传参数
            #没有terminate
            #join
        #active_count   int  当前程序中正在执行的线程个数
        #current_thread    线程对象  能够获取 当前线程 的对象

from multiprocessing import Process
class Myprocess(Process):
    def __init__(self,args):
        super().__init__()
        self.args = args
    def run(self):
        print('子进程执行',self.name)

p1 = Myprocess(1)
p1.start()       #self指向p1  和p1 是一样的   #和 current_thread一样
p1.join()


p2 = Myprocess(1)
p2.start()       #self指向p2  #水性杨花
p2.join()

今日内容

# 守护线程
# threading.enumerate
# 线程锁
    #互斥锁
    #递归锁
    #死锁现象
#线程队列
#进程池和线程池


3 不大对的enumeate 方法

#__author : 'liuyang' 
#date : 2019/4/18 0018 上午 9:24
from threading import Thread, enumerate,active_count
def func():
    print('in son thread')
Thread(target= func).start()
print(enumerate())
#[<_MainThread(MainThread, started 2788)>]
active_count = len(enumerate())
print(active_count)

老师讲

from threading import enumerate,Thread

def func():
    print('in son thread')

Thread(target=func).start()
print(enumerate()) # 返回一个存储着所有线程对象的列表
# active_count = len(enumerate())
# [<_MainThread(MainThread, started 1200)>,
# <Thread(Thread-1, started 4156)>]

4守护线程

#__author : 'liuyang' 
#date : 2019/4/18 0018 上午 9:27
from threading import Thread
import time
def daemon_func():
    while True:
        time.sleep(0.5)
        print('守护线程')

def son_func():
    print("start son")
    time.sleep(5)
    print('end son')
t = Thread(target=daemon_func)
t.daemon = True
t.start()
Thread(target=son_func).start()
time.sleep(3)
print('主线程结束了')

# 1. 主线程会等待子线程的结束而结束
# 2. 守护线程会随着主线程的结束而结束
    #守护线程会守护主线程 和 所有的子线程


# 进程会随着 主线程的结束而结束
    # 所有非守护线程终止，即使存在守护线程，进程运行终止
    # 所有守护线程终止，


# 问题
    #1. 主线程需不需要回收子线程的资源
        #不需要  ， 线程资源属于进程， 所以进程结束了，线程的资源自然就被回收了
    # 2 .主线程 为什么要等待子线程结束之后结束
        # 主线程结束意味着进程结束，所有的子线程都会结束
        # 要想让子线程能够顺利执行完，主线程只能等
    #3 守护线程 到底要怎么结束的
        #主线程结束了 进程也结束了 守护线程被主进程的结束结束掉了（守护了这个进程。。。）

#守护进程： 只会守护到主进程的代码结束
#守护线程： 会守护到 所有其它非守护线程的结束

5 线程

　　还要加锁 ？ GIL 的锁为了节省时间  没有很负责的锁住 浪费时间 只锁规定时间内（时间片）

#__author : 'liuyang' 
#date : 2019/4/18 0018 上午 10:10
# 线程里有必要要锁么？
# GIL 和 锁的关系        #轮流执行一个  cpu

from dis import dis
from threading import Thread,Lock

count = 0
# count = []
l = []
def add_func(lock):
    global count
    for i in range(200000):
        with lock :
            count += 1
        # count.append(1)
def sub_func(lock):
    global count
    with lock:
        for i in range(200000):
            count -= 1
    # i = 200000
    # while i >0 :
    #     if count:
    #         count.pop()
    #         i -= 1

def add_list():
    l.append(1)
# dis(add_func)
t_l = []
lock = Lock()
# for i in range(5):
#     t1 =Thread(target=add_func,args = (lock,))
#     t1.start()
#     t_l.append(t1)
#     t2 =Thread(target=sub_func,args= (lock,))
#     t2.start()
#     t_l.append(t2)
# for t in t_l:t.join()
# print(count)
dis(add_list)
# 数据不安全


'''    两个线程模拟  加载count 1  加载+  存回全局变量
 14          14 LOAD_GLOBAL              1 (count)
             16 LOAD_CONST               2 (1)
             18 INPLACE_ADD
             20 STORE_GLOBAL             1 (count)
             22 JUMP_ABSOLUTE           10
        >>   24 POP_BLOCK
        >>   26 LOAD_CONST               0 (None)
             28 RETURN_VALUE'''

# 当执行 STORE         +=  两步操作
# GIL  时间片 轮转 (700条 ):造成了数据不安全
    #锁保证一个时间短一个线程  但是 没执行完  没存值
        #不是python代码   而是底层cpu执行

# l.append(1)
'''     lst.append(1)  原子性:不可再分性      [1,1]
 30           0 LOAD_GLOBAL              0 (l)
              2 LOAD_ATTR                1 (append)
              4 LOAD_CONST               1 (1)
              6 CALL_FUNCTION            1          # 调函数
              8 POP_TOP                             #POP ：出栈  #pop是弹出栈顶元素，top是获得栈顶元素，不弹出
             10 LOAD_CONST               0 (None) 
             12 RETURN_VALUE'''

# if  [].pop()  #两步操作  轮转了  改变了 没法pop了 所以报错
#    +=         #两步操作  轮转了   没改变全局变量存到里面  所以有重叠

# 数据不安全
#在线程中也会出现数据不安全的
    #1.对全局变量进行修改
    #2.对某个值 += -= *= /=
# 通过加锁来解决

# 设计都写好的函数  修改的
# list pop append extend insert insert  remove
# dict pop update
# list[0] += 1
# dic[key] -= 1

#list.pop/append   # pop列表为空时会 报错
# queue  put/get   # get队列为空时会 等待


# GIL
#
# 如果没有GIL锁
# append(1)   append(1)  多个cpu同时进行
# 在一个列表地址中  被覆盖了

# 1 . 有了GIL 保证了线程同一时刻只能有一个线程访问CPU，不可能有两个线程t同时在cpu上执行指令
# 没有GIL操作  任何小操作都得加锁

# 2 lock 锁 保证某一段代码 在没有执行完毕之后，不可能有另一个线程也执行它
# 时间片轮转

6 科学家吃面问题

两个人 两个东西 得二可得天下 但是一人一个

#__author : 'liuyang' 
#date : 2019/4/18 0018 上午 10:54
#死锁： 永远解不开了才叫

# acquire # acquire  低级的死锁 好开
# '''
from threading import Lock
# 死锁代码  ：操作两个变量的 两个函数同时使用两个变量  时机问题  我有叉子 你有面
                                                # 自己代码没问题  没测到并发 很多线程  上线了服务
from threading import Thread                   #用户一多  多线程  死锁 阻在那了 不走了
noodle_lock = Lock()
fork_lock = Lock()
import time
def eat1(name):
    noodle_lock.acquire()
    print('%s 拿到面了'%name)
    fork_lock.acquire()
    print('%s 拿到叉子'%name)
    print('%s 吃面'%name)
    time.sleep(0.1)
    fork_lock.release()
    print('%s 放下茶子'%name)
    noodle_lock.release()
    print('%s 放下面'%name)
def eat2(name):
    fork_lock.acquire()
    print('%s 拿到叉子了'%name)
    noodle_lock.acquire()
    print('%s 拿到面了'%name)
    print('%s 吃面'%name)
    noodle_lock.release()
    print('%s 放下面' % name)
    fork_lock.release()
    print('%s 放下茶子'%name)

Thread(target=eat1 , args=('alex',)).start()
Thread(target=eat2 , args=('al',)).start()
Thread(target=eat1 , args=('ex',)).start()

# '''
 # 快速解决问题
            #改成一把锁
    #递归锁
    # 门口挂着一串(万能)钥匙 （互斥一个钥匙）
        #也是把两把锁并成 一把锁 ，别的结构不改
    # 很多个门

#lock.acquire()
    #拿到面了
#lock.acquire()
    #拿到叉子
    #吃面
#lock.release()
    #放下面
#lock.release()
    #放下叉子       #归还到最外层
#
# from threading import RLock , Lock
# lock = Lock()
# rlock = RLock()

# lock.acquire()
# print(123)
# lock.acquire()
# print(456)

# rlock.acquire()
# print(123)
# rlock.acquire()
# print(456)
# rlock.acquire()
# print(56)       #万能钥匙   可以近很多个锁门 但是得出来
# rlock.release()
# rlock.release()
# rlock.release()

# 搞两个锁都会锁 不管递归锁

# 在同一个线程中是不会出现数据安全（死锁）  的 所以 递归锁 可以
from threading import RLock , Lock,Thread
# fork_lock = noodle_lock = RLock()
# def eat1(name):
#     noodle_lock.acquire()
#     print('%s 拿到面了'%name)
#     fork_lock.acquire()
#     print('%s 拿到叉子'%name)
#     print('%s 吃面'%name)
#     fork_lock.release()
#     print('%s 放下茶子'%name)
#     noodle_lock.release()
#     print('%s 放下面'%name)
# def eat2(name):
#     noodle_lock.acquire()
#     print('%s 拿到叉子了'%name)
#     fork_lock.acquire()
#     print('%s 拿到面子'%name)
#     print('%s 吃面'%name)
#     fork_lock.release()
#     print('%s 放下茶子'%name)
#     noodle_lock.release()
#     print('%s 放下面'%name)
# Thread(target=eat1 , args=('l',)).start()
# Thread(target=eat1 , args=('y',)).start()

# lock = Lock()     #上面的效率低 改成  互斥锁
# def eat1(name):       #最简单  没问题
#     lock.acquire()
#     print('%s 拿到面了'%name)
#     print('%s 拿到叉子'%name)
#     print('%s 吃面'%name)
#     print('%s 放下茶子'%name)
#     print('%s 放下面'%name)
#     lock.release()
# def eat2(name):
#     lock.acquire()
#     print('%s 拿到面了'%name)
#     print('%s 拿到叉子'%name)
#     print('%s 吃面'%name)
#     print('%s 放下茶子'%name)
#     print('%s 放下面'%name)
#     lock.release()
# Thread(target=eat1 , args=('l',)).start()
# Thread(target=eat1 , args=('y',)).start()

#两个进程 各拿到一个 钥匙
    #都完不成
# 你要操作的数据不止一个   a = 1   b = 2   c = a+b

# a.acquire()
    #忘了解锁   阻塞在某个点了  可能锁了
# b.acquire()
# a.release()
# b.release()

# 出错了 改不出来了  就先把所有的锁  改成一个锁   没问题，但是效率不高
# 改好了， 再改一把把锁

# 获取锁  释放锁   不要把大段代码 放了锁里
    #一把锁锁一个资源

# 死锁不是锁

#互斥锁
#递归锁

7.队列

#__author : 'liuyang' 
#date : 2019/4/18 0018 下午 12:08
from queue import Queue
# Queue 就是一个线程队列的类， 自带 lock锁，实现了线程安全的数据类型
# 队列是一个线程安全的数据类型  放进去拿出来

# [][]+=1   不安全 列表
q = Queue()
q.put(1)

    #在多线程下都不准  异步没法控制
q.empty() #判断是否为空
q.full()  #判断是否为满
q.qsize()  #队列的大小

q.put({1,2,3})
q.get()
q.put_nowait({'abc'})
print(q.get_nowait())   #先进先出
print(q.get_nowait())

#先进后出 的 队列 last in first out
from queue import LifoQueue   #栈  后进先出的时候  都可以用过
lfq = LifoQueue()
lfq.put(1)
lfq.put('abc')
lfq.put({'1','2','3','4'})
print(lfq.get())
print(lfq.get())
print(lfq.get())

#  栈从空间复杂度上来讲  栈的效率要比递归高
#  队列来讲顺序性

from queue import PriorityQueue  #小的优先级高1   优先级队列
pq = PriorityQueue()
pq.put((1,'abcd'))
pq.put((2,'dcba'))
pq.put((20,'dddd'))
print(pq.get())
print(pq.get())
print(pq.get())              #设置成会员 抢票好

# 线程+队列 实现消费者生产者模型

8池 进程

#__author : 'liuyang' 
#date : 2019/4/18 0018 下午 12:08
from queue import Queue
# Queue 就是一个线程队列的类， 自带 lock锁，实现了线程安全的数据类型
# 队列是一个线程安全的数据类型  放进去拿出来

# [][]+=1   不安全 列表
q = Queue()
q.put(1)

    #在多线程下都不准  异步没法控制
q.empty() #判断是否为空
q.full()  #判断是否为满
q.qsize()  #队列的大小

q.put({1,2,3})
q.get()
q.put_nowait({'abc'})
print(q.get_nowait())   #先进先出
print(q.get_nowait())

#先进后出 的 队列 last in first out
from queue import LifoQueue   #栈  后进先出的时候  都可以用过
lfq = LifoQueue()
lfq.put(1)
lfq.put('abc')
lfq.put({'1','2','3','4'})
print(lfq.get())
print(lfq.get())
print(lfq.get())

#  栈从空间复杂度上来讲  栈的效率要比递归高
#  队列来讲顺序性

from queue import PriorityQueue  #小的优先级高1   优先级队列
pq = PriorityQueue()
pq.put((1,'abcd'))
pq.put((2,'dcba'))
pq.put((20,'dddd'))
print(pq.get())
print(pq.get())
print(pq.get())              #设置成会员 抢票好

# 线程+队列 实现消费者生产者模型

9总结

# 守护线程
#锁
    #互斥
    #递归
    #死锁现象

#队列  线程安全的数据
    #先进先出  queue
    #后进先出   LifoQueue
    #优先级队列  PriorityQueue

#池
    #控制进程的数量
    #节省资源开销