并发编程 之 线程 之 Thread 模块(数据共享, 守护线程), 锁Lock(递归锁), 信号量, 事件, 条件, 定时器 (二)

Thread 模块 from threading import Thread:

与进程的效率差别:

import time
from threading import Thread
from multiprocessing import Process
# 效率差别
def func(a):
    a = a + 1

if __name__ == '__main__':
    start = time.time()
    t_l = []
    for i in range(50):
        t = Thread(target=func,args=(i,))
        t.start()
        t_l.append(t)
    # t_l 50个线程对象
    for t in t_l : t.join()
    print('主线程')
    print(time.time() - start)

    start = time.time()
    t_l = []
    for i in range(50):
        t = Process(target=func, args=(i,))
        t.start()
        t_l.append(t)
    # t_l 50个线程对象
    for t in t_l: t.join()
    print('主进程')
    print(time.time() - start)



'''
跑一下后, 所显示的 时间差, 会非常明显的显出来

之所以会这样, 是因为 
      对于多进程来说:
            需要打开多个进程, 每个进程和进程之间都是独立的空间互不干扰, 所以在打开和关闭的时候 会消耗大量的时间, 
      对于 多线程来说:
            相当于只打开了一个进程, 在一个进程中实现了更多的操作, 这样可以减少 打开和销毁 进程的一部分时间, 不过, Cpython解释器里面的线程实现不了 并行, 对于抢占CPU的利用率来说 是一个很low的东西
'''        

效率差别

数据共享:
　　　　在进程中不存在数据共享, 如果想要共享数据,需要引用一些其他模块

　　　　在线程中, 数据是共享的

　　守护线程:

　　　　会等待主线程结束之后才结束, 主线程会等待所有子线程结束而结束
　　　　主线程结束, 整个进程结束, 所以 主线程需要等待所有线程结束后才能结束
　　　　setDaemon(True) 开启守护线程.

import time
from threading import Thread
def thread1():
    while True:
        print(True)
        time.sleep(0.5)

def thread2():
    print('in t2 start')
    time.sleep(3)
    print('in t2 end')

if __name__ == '__main__':
    t1 = Thread(target=thread1)
    t1.setDaemon(True)
    t1.start()
    t2 = Thread(target=thread2)
    t2.start()
    time.sleep(1)
    print('主线程')


# 主线程如果结束了 那么整个进程就结束
# 守护线程 会等待主线程结束之后才结束.
    # 主进程 等待 守护进程 子进程
    # 守护进程 只守护主进程的代码就可以了
    # 守护线程不行 主线程如果结束了 那么整个进程就结束 所有的线程就都结束

守护线程

用类开启线程:

　　　　继承Thread类, 在里面重写run()

from threading import Thread,get_ident

# threading.get_ident() 此方法可以用来查看线程 id
class MyThread(Thread):

    def run(self):
        print('in my thread : ',get_ident(),self.args)

print('main',get_ident())
t = MyThread('wahaha')
t.start()

用类开启线程 (不含参数)

若 方法中含有参数,  只需要在自己写的类中,重写 __init__() 构造方法, 同时继承父类的__init__() 方法:

from threading import Thread,get_ident
# 开启线程的第二种方式和查看线程id
class MyThread(Thread):
    def __init__(self,args):
        super().__init__()   # Thread类的init,在这个方法中做了很多对self的赋值操作,都是给创建线程或者使用线程的时候用的
        self.args = args

    def run(self):
        print('in my thread : ',get_ident(),self.args)

print('main',get_ident())
t = MyThread('wahaha')
t.start()

用类开启线程 (含参数)

线程中的其他方法:
　　　　is_alive() 判断是否活着
　　　　enumerate() 将正在进行的线程组成一个列表进行返回
　　　　activeCount() 计算正在运行的线程的数量

锁Lock, 递归锁PLack: 

　　在进程和线程中, 同时访问一个数据的时候就会产生数据不安全的现象 　　

　　GIL 全局解释器锁:
　　　　此锁是用来锁住解释器往CPU中传输需要计算的内容.

Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
　　对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。

　　在多线程环境中，Python 虚拟机按以下方式执行：

　　a、设置 GIL；

　　b、切换到一个线程去运行；

　　c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；

　　d、把线程设置为睡眠状态；

　　e、解锁 GIL；

　　d、再次重复以上所有步骤。
　　在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(由于在这期间没有Python的字节码被运行，所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。

GIL详解

　互斥锁: Lock
　　　　此锁是用来对内存进行锁定, 避免出现多线程 同时对某一数据进行增删改查,

　　　　用法和进程中的锁大概也一样, 只不过在进程中的 数据本身是不被共享的, 而这里的数据本身就是共享的, 所以往往在线程中出现的概率更大.

# 尽量不要设置全局变量
# 只要在多线程/进程之间用到全局变量 就加上锁

from threading import Lock,Thread
lock = Lock()
lock.acquire()
lock.acquire()
noodle = 100
def func(name,lock):
    global noodle
    lock.acquire()
    noodle -= 1
    lock.release()
    print('%s吃到面了'%name)

if __name__ == '__main__':
    lock = Lock()  # 线程锁 互斥锁
    t_lst = []
    for i in range(10):
        t = Thread(target=func,args=(i,lock))
        t.start()
        t_lst.append(t)
    for t in t_lst:
        t.join()
    print(noodle)

Lock

递归锁: PLock
　　　　此锁是用来解决, 在使用互斥锁的时候出现的死锁的状况

　　死锁现象: 本质上还是代码的逻辑出现了问题,
　　　　所以 递归锁只是用来进行修补的强力胶, 而不是一个正常代码中的逻辑方法

ps:
　　　　死锁:
　　　　　　多把锁同时应用在多个线程中

　　　　互斥锁和递归锁哪个好:

　　　　　　递归锁 快速恢复服务
　　　　　　死锁问题的出现 是程序的设计或者逻辑的问题
　　　　　　还应该进一步的排除和重构逻辑来保证使用互斥锁也不会发生死锁

　　　　互斥锁和递归锁的区别:
　　　　　　互斥锁 就是在一个线程中不能连续多次ACQUIRE
　　　　　　递归锁 可以在同一个线程中acquire任意次,注意acquire多少次就需要release多少次

信号量 Semphore:
　　池与信号量的区别:

　　　　池 效率高:
　　　　　　池子里有几个进程/线程 一共就几个进程/线程
　　　　　　不管有多少任务, 池子的个数都是固定的
　　　　　　开启进程和关闭进程这些事都是需要固定的时间开销
　　　　　　不产生额外的时间开销
　　　　　　且进程池中的进程数控制的好, 那么操作系统的压力越小

　　　　信号量:
　　　　　　有多少个任务就开多少 进程/线程
　　　　　　可以帮助你进啊少操作系统切换的负担
　　　　　　但是并不能帮助你减少 进程/线程的开启和关闭的时间,
　　　　　　所以 信号量的效率略低

事件 Even: 同进程的事件整体来说是一样的.
　　方法:
　　　　wait() 等待, 
　　　　set()
　　　　clear()
　　　　is_set()

条件:Condition
　　方法:
　　　　acquire()
　　　　release() 
　　　　wait() 阻塞
　　　　notify() 让wait接触阻塞

　　ps: wait() 和 notify() 必须在执行这两个方法的前后加上 acquire()和release()

定时器 Timer:

　　定时器，指定n秒后执行某个操作

from threading import Timer
 
def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed