python全栈开发 * 线程锁 Thread 模块 其他 * 180730

一,线程Thread模块
1.效率更高(相对于进程)

import time
    from multiprocessing import Process
    from threading import Thread
    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_l.append(t)
            t.start()
        for t in t_l:
            t.join()
        print("主线程结束")
        print(time.time()-start)       # 0.010993003845214844


        start=time.time()
        p_l=[]
        for i in range(50):
            p=Process(target=func,args=(i,))
            p_l.append(p)
            p.start()
        for p in p_l:
             p.join()
        print("主进程")
        print(time.time()-start)       # 6.235144376754761

2.线程之间的数据共享   (进程中数据是隔离的):

from threading import Thread
    n=100
    def func():
        global n       #子线程引用主线程的变量       (进程中不可以引用)
        n=n-1           #并修改主线程的变量值

    t_l=[]
    for i  in range(100):
        t=Thread(target=func)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()
    print(n)       # 0

3.守护线程

import time
    from threading import Thread
    def func1():
        while True:
            print("True")      #4.打印True  11.**   13.**
            time.sleep(0.5)      # 5.睡1 秒   #12.又休1秒   14.又休1秒


    def func2():
        print("in f2 start")     #8打印in f2 start
        time.sleep(3)              #9,休3秒
        print("in f2 end")       #15打印   in f2  end


    t1=Thread(target=func1)    #1.创建一个线程
    t1.setDaemon(True)         #2.设置成守护进程
    t1.start()                 #3.申请开启线程
    t2=Thread(target=func2)     #6.创建另一个线程
    t2.start()                  #7.申请开启另一个线程
    time.sleep(1)               # 12.**
    print('主线程')            #10.  打印主线程总结:主线程如果结束了,那么整个进程就结束,所有线程就结束

    守护进程:只守护主进程的代码就可以了,守护进程会在主进程的代码执行完毕之后直接结束,无论守护进程是否执行完毕

4.开启线程的第二种方式:

import time
    from threading import Thread,get_ident
    class MyThread(Thread):
        def __init__(self,args):
            super().__init__()
            self.args=args

        def run(self):
            print("in my thread:" ,get_ident(), self.args)
    print("in main",get_ident())      # in main 11676
    m=MyThread("hahaha")
    m.start()                          #  in my thread: 22100 hahaha

5.Thread类的其他方法
Thread实例对象的方法:
    isAlive():返回线程是否执行
    getName():返回线程名
    setName():设置线程名

threading模块提供的一些方法:
    threading.currentThread():返回当前的线程变量
    threading.enumerate():返回一个包含正在运行的线程的list,正在运行指线程启动后、结束前，不包括启动前和终止后的线程
    threading.activeCount() :返回正在运行的线程数量,与len(threading.enumerate())有相同的结果
示例:

import time
    import threading
    from threading import Thread,get_ident,currentThread
    print(threading.currentThread().getName())     #  MainThrea
    print(threading.enumerate())    #[<_MainThread(MainThread, started 9780)>]
    print(threading.activeCount())   #1

二.线程中的锁 Lock

1. 什么时候用锁:
    在多个进程线程同时访问一个数据的时候就会产生数据的不安全的现象
2.区别GIL 全局解释器锁
    在同一个进程里的每一个线程同一时间只能有一个线程访问CPU
3.尽量不要设置全局变量
    只要在多线程/进程之间用到全局变量,就加上锁
第一版:

import time
    import threading
    from threading import Thread,get_ident,currentThread
    print(threading.currentThread().getName())     #  MainThrea
    print(threading.enumerate())    #[<_MainThread(MainThread, started 9780)>]
    print(threading.activeCount())   #1

第二版:科学家吃面:
1.死锁现象:
    所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，
    它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程

import time
    from threading import Thread,Lock
    lock=Lock()
    noodle_lock=Lock()
    fork_lock=Lock()
    def eat1(name):
        noodle_lock.acquire()
        print("%s拿到了面" % name)
        fork_lock.acquire()
        print("%s拿到了叉子"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        fork_lock.release()
        noodle_lock.release()


    def eat2(name):
        fork_lock.acquire()
        print("%s拿到了叉子"%name)
        noodle_lock.acquire()
        print("%s拿到面条"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        noodle_lock.release()
        fork_lock.release()
    eat_l=["alex","wusir","太白","苑"]
    for name in eat_l:
        Thread(target=eat1,args=(name,)).start()
        Thread(target=eat2,args=(name,)).start()

2.递归锁(Rlock):
        递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
        这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一
    个线程所有的acquire都被release，其他的线程才能获得资源
3.用递归锁解决上述死锁问题:

import time
    from threading import Thread,RLock
    lock=RLock()

    def eat1(name):
        lock.acquire()
        print("%s拿到了面" % name)
        lock.acquire()
        print("%s拿到了叉子"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        lock.release()
        lock.release()


    def eat2(name):
        lock.acquire()
        print("%s拿到了叉子"%name)
        lock.acquire()
        print("%s拿到面条"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        lock.release()
        lock.release()
    eat_l=["alex","wusir","太白","苑"]
    for name in eat_l:
        Thread(target=eat1,args=(name,)).start()
        Thread(target=eat2,args=(name,)).start()

4.互斥锁解决死锁问题

import time
    from threading import Thread,Lock
    lock=Lock()

    def eat1(name):
        lock.acquire()
        print("%s拿到了面" % name)
        print("%s拿到了叉子"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        lock.release()


    def eat2(name):
        lock.acquire()
        print("%s拿到了叉子"%name)
        print("%s拿到面条"%name)
        print("%s在吃面"%name)
        time.sleep(0.5)
        lock.release()

    eat_l=["alex","wusir","太白","苑"]
    for name in eat_l:
        Thread(target=eat1,args=(name,)).start()
        Thread(target=eat2,args=(name,)).start()

面试题:
    互斥锁和递归锁哪个好:
        递归锁     快速恢复服务
        死锁问题的出现是程序的设计或者逻辑的问题
        还应该进一步的排除和重构逻辑来保证使用互斥锁也不会发生死锁
    互斥锁与递归锁的区别:
        互斥锁:就是在一个线程中不能连续多次acquire
        递归锁:可以在同一个线程中acquire任意次,注意acquire多少次就需要release多少次
三.线程中的信号量 Semaphore

信号量: 锁 + 计数器
信号量  VS  进程池

 import time
    from multiprocessing import Semaphore,Process,Pool
    def ktv1(sem,i):
        sem.acquire()
        i+=1
        sem.release()
    def ktv2(i):
        i+=1
   if __name__=="__main__":
    #信号量
        sem=Semaphore(5)
        start=time.time()
        p_l=[]
        for i in range(100):
            p=Process(target=ktv1,args=(sem,i))
            p.start()
            p_l.append(p)
        for p in p_l:
            p.join()
        print("###",time.time()-start)            # 7.551328897476196
    #进程池
        start=time.time()
        p = Pool(5)
        for i in range(100):
            ret=p.apply_async(func=ktv2,args=(p,i))
        p.close()
        p.join()
        print("@@@",time.time()-start)        #@@@ 1.013512372970581

Thread信号量:

import time
    from threading import Semaphore,Thread
    def ktv1(sem, i):
        sem.acquire()
        i += 1
        sem.release()
    def ktv2(i):
        i += 1
    if __name__ == "__main__":
        sem = Semaphore(5)
        start = time.time()
        p_l = []
        for i in range(100):
            t = Thread(target=ktv1, args=(sem, i))
            t.start()
            p_l.append(t)
        for t in p_l:
            t.join()
        print("###", time.time() - start)  #  ### 0.01998734474182129

总结:
    进程池
    进程池的效率更高;
    池子里有几个就起几个
    不管多少任务,池子的个数是固定的
    开启进程和关闭进程这些事都是需要固定的开销的
    不产生额外的时间开销
    信号量:
    有多少任务就起多少进程/线程
    可以帮助你减少操作系统切换的负担
    但是并不能帮助你减少进程/线程开启和关闭的时间
四.线程中的事件 Event

事件四个方法:
    wait : 等到事件内部的信号变成True就不阻塞了,
    set: 设置信号为True
    clear : 设置信号变成False
    is_set : 查看信号是否为True
示例:

import time
    import random
    from threading import Thread,Event
    def check(e):
        print("正在检测两台机器之间的网络情况")
        time.sleep(random.randint(0,2))
        e.set()
    
    def connect_db(e):
        n = 0
        while n < 3:
            if e.is_set():
                break
            else:
                e.wait(0.5)
                n += 1
        if n == 3:
            raise TimeoutError
        print('连接数据库 ... ')
        print('连接数据库成功~~~')
    e=Event()
    Thread(target=connect_db,args=(e,)).start()
    Thread(target=check,args=(e,)).start()

五.条件 Condition

condition :
    Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个
    条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，
    其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。
condition 的相关方法
acquire
release
wait  阻塞
notify   让wait解除阻塞的工具
在执行wait和notify这两个方法的前后 必须执行acquire和release

from threading import Condition,Thread
    def func(con,i):
        con.acquire()
        con.wait()
        print("threaing:",i)
        con.release()

    con=Condition()
    for i in range(20):
        Thread(target=func,args=(con,i)).start()
    con.acquire()
    con.notify_all()
    con.release()
    while True:
        num=int(input("num>>>"))
        con.acquire()
        con.notify(num)
        con.release()

六.定时器 Timer

指定n秒后执行某个操作

from threading import Timer
def func():
    print("in func,执行吧")
Timer(1,func).start()

 七.多线程起socket(tcp)

服务器代码

import socket
import os
sk=socket.socket()
sk.connect(("127.0.0.1",9991))
while True:
    print(sk.recv(1024))
    sk.send(str(os.getpid()).encode('utf-8'))
sk.close()

客户端代码

import socket
import os
sk=socket.socket()
sk.connect(("127.0.0.1",9991))
while True:
    print(sk.recv(1024))
    sk.send(str(os.getpid()).encode('utf-8'))
sk.close()