python并发编程之多线程（2）（操作篇）

目录：

• 一 threading模块介绍
• 二 开启线程的两种方式
• 三 在一个进程下开启多个线程与在一个进程下开启多个子进程的区别
• 四 练习
• 五 线程相关的其他方法
• 六 守护线程
• 七 Python GIL(Global Interpreter Lock)
• 八 同步锁
• 九 死锁现象与递归锁
• 十 Event
• 十一 Python标准模块--concurrent.futures

一 threading模块介绍

multiprocessing模块完全模仿了threading模块的接口，二者在使用层面，有很大的相似性，因而不再详细介绍

官网链接：https://docs.python.org/3/library/threading.html?highlight=threading#

二 开启线程的两种方式

方式一

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

if __name__ == '__main__':
    t = Thread(target=syahi, args=('egon', ))
    t.start()
    print('主线程')

方式二

from threading import Thread
import time

class Sayhi(Thread)
    def __init__(self,name):
        super().__init()
        self.name = name
    def run(name):
        time.sllep(2)
        print('%s say hello' % name)

if __name__ == '__main__':
    t = Syahi('egon')
    t.start()
    print('主线程')

 

 

三 在一个进程下开启多个线程与在一个进程下开启多个子进程的区别

1 谁的开启速度快

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
    主线程/主进程
    """
    
    # 在主进程下开启子进程
    p = Process(target=work)
    p.start()
    print('主线程/主进程')
    """
    打印结果：
    主线程/主进程
    hello
    """

2 瞅一瞅pid

from threading import Thread
from multiprocessing import Process
import os

def work():
    print('hello',os.getpid())

if __name__ == '__man__':
    #part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print('主线程/主进程pid',os.getpid())

    #part2:开多个进程,每个进程都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print('主线程/主进程pid',os.getpid())

3 同一进程内的线程共享该进程的数据？

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,因为同一进程内的线程之间共享进程内的数据

四 练习

练习一：

多线程并发的socket服务端

#_*_coding:utf8_*_
#!/user/bin/env python
import multiprocessing 
import threading
import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 8080))
s.listen(5)

def action(conn):
    while True:
        data = conn.recv(1024)
        print(data)
        conn.send(data.upper())

if __name__ == '__main__':
    while True:
        conn, addr = s.accept()
        
        p = threading.Thread(target=action, args=(conn, ))
        p.start()

客户端

import socket

s = socket.socket(socket.AF_INET， socket.SOCK_STREAM)
s.connect(('127.0.0.1', 8080))

while True:
    msg = input('>>>:').strip()
    if not msg:
        continue
    s.send(msg.encode('utf8'))
    data=s.recv(1024)
    print(data)

练习二：三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件

from threading import Thread
msg_l = []
format_l = []
def takl():
    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='utf8') 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 Threadimport threadingfrom multiprocessing 
import Processimport osdef 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)>]    2    主线程/主进程    Thread-1    '''

主线程等待子线程结束

from threading import 
Threadimport timedef 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 Threadimport 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    '''

例题

from threading import Threadimport time
def foo():    
print(123)    
time.sleep(1)    
print("end123")
def bar():    
print(456)    
time.sleep(3)    
print("end456")
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()
print("main-------")

七 Python GIL（Global Interpreter Lock）

链接：http://www.cnblogs.com/linhaifeng/articles/7449853.html

八 同步锁

三个需要注意的点：#1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，
即便是拿到执行权限GIL也要立刻交出来#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只是锁住一部分操作共享数据的代码。

详细

因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 
里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的
内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题，  
这可以说是Python早期版本的遗留问题。

from threading import Threadimport os,time
def work():    
　　global n    temp=n    time.sleep(0.1)    n=temp-1
　　if __name__ == '__main__':    
　　　　n=100    l=[]    
　　　　for i in range(100):        
　　　　　　p=Thread(target=work)        
　　　　　　l.append(p)        
　　　　　　p.start()    
　　　　　　for p in l:        　　
　　　　　　　　p.join()    　　
　　　　　　　　print(n) #结果可能为99

GIL锁与互斥锁综合分析（重点）

分析：　　
#1.100个线程去抢GIL锁，即抢执行权限
#2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
#3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
#4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

九 死锁现象与递归锁

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

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线

十 Event

同进程的一样

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

event.isSet()  返回event的状态值event.wait()  如果event,isSet() == False将阻塞线程event.set()  设置event的状态值为True，所有阻塞池的线程激活进入就绪状态，
等待操作系统调度event.clear()  恢复event的状态值为False

 

十一 Python标准模块--concurrent.futures

https://docs.python.org/dev/library/concurrent.futures.html

十二  进程池与线程池

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from multiprocessing import Process
def task(n, m):
    return n + m

def task1(n, m):
    return n + m

# 回调函数
def callback(res):
    print(res)
    print(res.result())
def callback1(res):
    print(res)
    print(res.result())

if __name__ == '__main__':
    # 启一个进程池，里面启了5个进程
    p_pool = ProcessPoolExecutor(5)
    # p = Process(target=task)
    # p.start()

    p_pool.submit(task, n=1, m=2).add_done_callback(callback)
    p_pool.submit(task1, n=2, m=2).add_done_callback(callback1)
    p_pool.shutdown() # 就相当于join
    '''
        回调函数：
    '''
    # 告诉进程池里面的进程回调哪个函数？
    print('主进程')