python之多线程

一、threading 模块

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性

二、开启线程的两种方式

from threading import thread
import time
def hello(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=thread(target=hello,args=('xiaomao',))
    t.start()
    print('主线程')

方式一

from threading import thread
import time
class hello(thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = hello('xiaomao')
    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
    '''

1、开启速度（线程快）

from threading import thread
from multiprocessing import process
import os

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

if __name__ == '__main__':
    #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())

线程pid相同，进程则不同

from  threading import thread
from multiprocessing import process
import os
def work():
    global n
    n=0
    print('%s  子进程'%(n))
if __name__ == '__main__':
    # n=100
    # p=process(target=work)
    # p.start()
    # p.join()
    # print('主',n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100


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

线程共享数据，进程彼此隔离

 

四、练习题

from threading import thread
import socket

server=socket.socket(socket.af_inet,socket.sock_stream)
server.bind(('127.0.0.1',9999))
server.listen(5)


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

if __name__ == '__main__':

    while true:
        conn,addr=server.accept()
        p=thread(target=action,args=(conn,))
        p.start()

多线程实现socket并发（服务端）

import socket

s=socket.socket(socket.af_inet,socket.sock_stream)

s.connect(('127.0.0.1',9999))

while true:
    cmd=input('>>>:').strip()
    if len(cmd) ==0:continue
    s.sendall(cmd.encode('utf-8'))
    data=s.recv(1024)
    print(data)

客户端

2、多任务并发(一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件)

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()

view code

五、线程相关方法

thread实例对象的方法
  # isalive(): 返回线程是否活动的。
  # getname(): 返回线程名。
  # setname(): 设置线程名。

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

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
    '''

join 操作 与 进程一样

六、守护线程

无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁

需要强调的是：运行完毕并非终止运行

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

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

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

详细

from threading import thread
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    t=thread(target=task,args=('线程1',))
    t.daemon=true
    t.start()
    print('主')
# ps:  daemon 在 start 的上面
# 守护进程会在主进程内那个主线程代码运行完毕后就立即销毁
# 守护线程会在该进程内所有非守护的线程都运行完毕后才结束

七、gil（全局解释器锁）

gil本质就是一把互斥锁，有了gil的存在会导致同一个进程下的多个线程不能够并行但能够并发

点我-----------------点我---------------------点我--------------------

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

为何有gil

八、互斥锁

注意的点：
#1.线程抢的是gil锁，gil锁相当于执行权限，拿到执行权限后才能拿到互斥锁lock，其他线程也可以抢到gil，但如果发现lock仍然没有被释放则阻塞，即便是拿到执行权限gil也要立刻交出来

#2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分‘串行’，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

python已经有一个gil来保证同一时间只能有一个线程来执行了，为什么这里还需要lock? 

　 锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

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

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

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

gil与互斥锁分析

#join是所有线程从头到尾串行执行
#而加锁的话只有上锁的部分是串行执行

加锁与join的区别

from threading import thread
import 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



#加锁：

import threading

r=threading.lock()

r.acquire()
'''
对公共数据的操作
'''
r.release()

#--------------------------------------------------------------------------
from threading import thread,lock
import os,time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=lock()
    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) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

示例

九、死锁与递归锁（进程与线程）

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

from threading import thread,lock
import time
mutexa=lock()
mutexb=lock()

class mythread(thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexa.acquire()
        print('\033[41m%s 拿到a锁\033[0m' %self.name)

        mutexb.acquire()
        print('\033[42m%s 拿到b锁\033[0m' %self.name)
        mutexb.release()

        mutexa.release()

    def func2(self):
        mutexb.acquire()
        print('\033[43m%s 拿到b锁\033[0m' %self.name)
        time.sleep(2)

        mutexa.acquire()
        print('\033[44m%s 拿到a锁\033[0m' %self.name)
        mutexa.release()

        mutexb.release()

if __name__ == '__main__':
    for i in range(10):
        t=mythread()
        t.start()

'''
thread-1 拿到a锁
thread-1 拿到b锁
thread-1 拿到b锁
thread-2 拿到a锁
然后就卡住，死锁了
'''

死锁现象

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

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

mutexa=mutexb=threading.rlock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

十、信号量

同进程的一样

semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

from threading import thread,semaphore
import threading
import time
# def func():
#     if sm.acquire():
#         print (threading.currentthread().getname() + ' get semaphore')
#         time.sleep(2)
#         sm.release()
def func():
    sm.acquire()
    print('%s get sm' %threading.current_thread().getname())
    time.sleep(3)
    sm.release()
if __name__ == '__main__':
    sm=semaphore(5)
    for i in range(23):
        t=thread(target=func)
        t.start()

view code

与进程池是完全不同的概念，进程池pool(4)，最大只能产生4个进程，而且从头到尾都只是这四个进程，不会产生新的，而信号量是产生一堆线程/进程

 非常建议读读

十一、事件event