python并发编程之多线程

Posted 2020-10-04

开启线程的两种方式：

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘%name)
if__name__==‘__main__‘:
    t=Thread(target=sayhi,args=(‘egon‘,))
    t.start()
    print(‘主线程‘)

方式一

from threading import Thread
import time
class Sayhi(Thread):
    def__init__(self,name):
        supper().__init__()
        self.name=name
    def run(self):
        time.sleep(2):
        print(‘%s say hello‘%self.name)
if __name__==‘__main__‘:
    t=Say(‘egon‘)
    t.start()
    print(‘主线程‘)

方式二

在这里我要说明一下他们谁的开启速度快

from threading import Thread
from multiprocessing import Process
import os

def work():
    print(‘hello‘)

if __name__ == ‘__main__‘:
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()
    print(‘主线程/主进程‘)
    ‘‘‘
    打印结果:
    hello
    主线程/主进程
    ‘‘‘

    #在主进程下开启子进程
    t=Process(target=work)
    t.start()
    print(‘主线程/主进程‘)
    ‘‘‘
    打印结果:
    主线程/主进程
    hello

很明显我们可以看到：在线程里面会先打印子线程在打印主线程,而在进程里面会先打印主进程然后打印子进程。（在这里我想简单的说一下，就是说你开启一个进程，你得去重新获得资源，然而开启线程的时候，资源已经存在了，不需要去开辟新的资源，所以它的开启速度就会明显快了好多）

补充：开启一个线程，在他之上有一个进程，我们在开启线程的时候回自动产生一个线程，这个线程就叫做主线程，开启的线程叫做其他线程（为什么不叫做子线程呢，就是因为在这里线程他只是共享资源，他们之间没有任何的依赖关系）

接下来讲一下：同一进程内的线程共享该进程的数据（资源）

from  threading import Thread
from multiprocessing import Process
import os
def work():
    global n
    n=0

if __name__ == ‘__main__‘:
    # n=100
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print(‘主‘,n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100


    n=1
    t=Thread(target=work)
    t.start()
    t.join()
    print(‘主‘,n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据

（在这里我要简单的说明一下，为什么同一进程内的线程可以共享该进程的数据，从这个实例中我们可以清楚的看到，在进程中，子进程他只是将自己的n改成了0，而父进程的n始终都是100，而对于线程来说，n的结果是0，这就是因为，同一进程内的线程共享该进程的数据）

实例：三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件（首先，在这里面三个任务是同时执行的，）

from threading import Thread
msg_l=[]
format_l=[]
def talk():
    while True:
        msg=input(‘>>: ‘).strip()
        if not msg:continue
        msg_l.append(msg)

def format_msg():
    while True:
        if msg_l:
            res=msg_l.pop()
            format_l.append(res.upper())

def save():
    while True:
        if format_l:
            with open(‘db.txt‘,‘a‘,encoding=‘utf-8‘) as f:
                res=format_l.pop()
                f.write(‘%s\n‘ %res)

if __name__ == ‘__main__‘:
    t1=Thread(target=talk)
    t2=Thread(target=format_msg)
    t3=Thread(target=save)
    t1.start()
    t2.start()
    t3.start()

线程相关的其他方法：

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

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

from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())


if __name__ == ‘__main__‘:
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()

    print(threading.current_thread().getName())
    print(threading.current_thread()) #主线程
    print(threading.enumerate()) #连同主线程在内有两个运行的线程
    print(threading.active_count())
    print(‘主线程/主进程‘)

    ‘‘‘
    打印结果:
    MainThread
    <_MainThread(MainThread, started 140735268892672)>
    [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
    主线程/主进程
    Thread-1
    ‘‘‘

主线程等待子线程结束

复制代码
from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘ %name)

if __name__ == ‘__main__‘:
    t=Thread(target=sayhi,args=(‘egon‘,))
    t.start()
    t.join()
    print(‘主线程‘)
    print(t.is_alive())
    ‘‘‘
    egon say hello
    主线程
    False
    ‘‘‘
复制代码

守护线程：

无论是进程还是线程，都是：守护xxx会等待主xxx完毕后被销毁，

主进程与主线程在什么情况下才算运行完毕

1.主进程在其代码结束后就已经算运行完毕了，（守护进程就在此时被回收）。主进程会一直等非守护的子进程都运行玩不后回收子进程的资源，（否则会产生僵尸进程），才会结束

2.主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。主线程的结束意味着进程的结束，进程整体的资源都被回收，因而主线程必须在其余非守护线程都运行完毕后才能结束

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘ %name)

if __name__ == ‘__main__‘:
    t=Thread(target=sayhi,args=(‘egon‘,))
    t.setDaemon(True) #必须在t.start()之前设置
    t.start()

    print(‘主线程‘)
    print(t.is_alive())
    ‘‘‘
    主线程
    True

八 同步锁

三个需要注意的点：
#1.分析Lock的同时一定要说明：线程抢的是GIL锁，拿到执行权限后才能拿到互斥锁Lock

#2.使用join与加锁的区别：join是等待所有，即整体串行，而锁只是锁住一部分，即部分串行

#3. 一定要看本小节最后的GIL与互斥锁的经典分析

GIL VS Lock

    机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock? 

　首先我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

    然后，我们可以得出结论：保护不同的数据就应该加不同的锁。

　最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock

过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限

　　线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果

　　既然是串行，那我们执行

　　t1.start()

　　t1.join

　　t2.start()

　　t2.join()

　　这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。