Python的并发与线程

并发的基本概念

并发与并行的区别

并行（paralel):同时做某些事，可以互不干扰的同一时刻做几件事

并发（concurrency）:同时做某些事，但是强调一个时间段内有事情要处理

举例：

乡村公路上一条车道，半边路面发生坍塌，交警指挥交通，众多车辆要在这一时段内要通过路面的时间，就是并发

高速公路的上的双向4车道，所有车辆可以互不干扰的在自己车道上互不干扰的奔跑，在同一个时刻，每条车道上了能同时存在有车辆在行驶，是同时发生的，这就是并行

并发的解决

食堂打饭模型

中午12点，开饭了，大家都永祥食堂，这就是并发，如果人很多，就是高并发

1、队列，缓冲区

假设只有一个窗口，陆续涌入食堂的人，排队打饭是比较好的方式

所以排队（队列）是一种天然的解决并发的方法

排队就是把人排成队列，先进先出，解决了资源使用的问题

排成的队列，其实就是一个缓冲的地带，就是缓冲区

把要处理的数据排成一个队列，其实就是一个缓冲地带，缓冲区

例如queue模块的类Queue、LifoQueue、PriorityQueue

2、争抢

只开一个窗口，有可能没有秩序，也就是谁挤进去就给谁打饭。挤到窗口的人占据窗口，直到打到饭菜离开

其他人继续争抢，会有一个人占据窗口，可以视为锁定窗口，窗口就不能为其他人提供服务了，这是一种锁机制，谁抢到资源就上锁，排他性的锁，其他人只能等待

争抢也是一种解决高并发的方案，但是这样不好，因为可能有人很长时间都抢不到

3、预处理

如果排长队的原因是由于每个人打菜等候时间长，因为要吃的菜没有，需要现做，没打到饭不走开，锁定着窗口

食堂可以提前统计大多数人最爱吃的菜品，将最爱吃的80%的热门菜，提前做好，保证供应

这样大多数人，就算锁定窗口，也很快就释放窗口了

一种提前加载用户需要的数据的思路，缓存用的就是预处理思想

4、并行

成百上千的人同时来吃饭，一个队伍搞不定的，多开打饭窗口形成多个队列，如同多开车道一样，并行打菜

开窗口就得扩大食堂，得多雇人在每个窗口上提供服务，造成成本上升

日常可以通过购买更多服务器，或多开进程，线程实现并行处理，来解决并发问题

注意这些都是水平扩展思想

注：如果线程在单CPU上处理，就不是并行
但是多数服务器都是多CPU的，服务部署往往是多机的，分布式的，这都是并行处理

5、提速

提高单个窗口的打饭速度，也是解决并发的方式

打饭人员提高工作技能，或为单个窗口配置更多的服务人员，都是提速的方法

提高单个CPU的性能，或单个服务器安装更多的CPU

这是一种垂直扩展的思想

6、消息中间件

北京的上地，西二旗地铁站外的九曲回肠的走廊，缓冲人流，进去之后再多个安检进站

常见的消息中间件有RabbitMQ、ActiveMQ（Apache)、RocketMQQ（阿里Apache)、kafka(Apache)等

当然还有其它手段解决并发问题，但是已经列举了最常用的解决方案，一般来说不同的并发场景应用不同的策略，而策略可能是多种方式的组合

例如多开食堂（多地），也可以把食堂建设到宿舍生活区（就近），所以说，计数来源于生活

进程和线程

在实现了线程的操作系统中，线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程的实际运作单位，一个程序的执行实例就是一个进程

进程：计算机中的程序关于某数据集合上的依次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础

Linux进程有父进程、子进程，Windows的进程是平等关系

线程：程序执行流的最小单元，有时也被称为轻量级进程（Lightweight Process,LWP)

一个标准的线程由线程ID，当前指令指针（PC），寄存器集合和堆栈组成

在许多系统中，创建一个线程比创建一个进程快10-100倍

进程、线程的理解

现代操作系统中提出进程的概念，每一个进程都认为自己独占所有的计算机硬件资源

进程就是独立的王国，进程间不可以随便的共享数据

线程就好像是省份，同一个进程内的线程是可以共享进程的资源，每一个线程拥有自己独立的堆栈

线程的状态

状态	含义
就绪（Ready)	线程能够运行，但在等待被调度，可能线程刚刚创建启动，或刚刚从阻塞中恢复，或者被其他线程抢占
运行（Running)	线程正在运行
阻塞（Rlocked)	线程等待外部事件发生而无法运行，如I/O操作
终止（Terminated)	线程完成或退出，或被取消

Python中的线程开发

Python的线程开发使用threading

Thread类

签名

def __int__(self,group=None,target=None,name=None,args=(),kwargs=None,*,daemon=None)

参数名	含义
target	线程调用的对象，就是函数目标
name	为线程起个名字
args	为目标函数传递实参，元组
kwargs	为目标函数关键字传参，字典

线程启动

import threading
#最简单的线程程序
def worker():
print('I am working')
print('Finished')

t = threading.Thread(target=worker,name='worker') #线程对象

t.start() #启动

通过threading.Thread创建一个线程对象，target是目标函数，那么可以制定名称。

但是线程没有启动，需要调用start方法

线程之所以执行函数，是因为线程中就是执行代码的，而最简单的的封装就是函数，所以还是函数调用

函数执行完，线程也就退出了

那么，如果不让线程退出，或者让线程一直工作怎么办呢？

import threading
import time

def worker():
    while True:  #增加一个死循环
        time.sleep(1)
        print('I am working')
    pritn('Finished')

t = threading.Thread(target=worker,name='worker')
t.start()

线程退出

Python没有提供线程退出的方法，线程在下面的情况时会退出

1、线程函数内语句执行完毕

2、线程函数中抛出未处理的异常

import threading
import time

def worker（):
    count = 0
    while True:
    if count > 5:
        #raise RuntimeError(count)
        #return
        break
    time.sleep(1)
    print('I am working')
    count += 1

t = threading.Thread(target=worker,name='worker')
t.start()

Python的线程没有优先级，没有线程组的概念，也不能销毁、停止、挂起

线程的传参

import threading
import time

def add(x,y):
print('{} + {} = {}'.format(x,y,x+y,threading.current_thread().ident))

t1 = threading.Thread(target=add,name='add',args=(4,5))
t1.start()
time.sleep(2)

t2 = threading.Thread(target=add,name='add',args=(5,),kwargs={'y':4})
t2.start()
time.sleep(2)

t3 = threading.Thread(target=add,name='add',kwargs{'x':4,'y':5})
t.start()

线程的传参和函数传参没有区别，本质上就是函数传参。

threading的属性和方法

名称	含义
current_thread()	返回当前线程对象
main_thread()	返回主线程对象
active_count()	处于alive状态的线程个数
enumerate()	返回所有活着的线程列表，不包括已经终止的线程和未开始的线程
get_indent()	返回当前线程的ID，非0整数

active_count,enumerate方法返回的值还包括主线程

import threading
import time

def showthreadinfo():
    print('currentthread = {}'.format(threading.current_thread()))
    print('main thread = {}'.format(threading.main_thread()))
    print('active count = {}'.format(threading.active_count()))

def worker():
    count = 0
    showthreadinfo()
    while True:
        if count > 5:
            break
        time.sleep(1)
        count += 1
        print('I am working')

t = threading.Thread(target=worker,name='worker')
showthreadinfo()
t.start()

print('===End===')

Thread实例的属性和方法

名称	含义
name	只是一个名字，只是个标识，名称可以重名，getName()、setName()获取、设置这个名词
ident	线程ID，它是非0的整数。线程启动后才会有ID，否者为None.线程退出，此ID依旧可以访问，可以重复使用
is_alive()	返回线程是否还在运行

注意：线程的name是一个名称，可以重复。ID必须唯一，但可以在线程退出后再利用

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
    time.sleep(1)
    count += 1
    print(threading.current_thread().name)

t = threading.Thread(target=worker,name='worker')
print(t.ident)
t.start()

while True:
    time.sleep(1)
    if t.is_alive():
        print('{} {} alive'.format(t.name,t.ident))
    else:
        print('{} {} dead'.format(t.name,t.ident))

名称	含义
start（）	启动线程，每一个线程必须且只能执行一次该方法
run()	运行线程函数

start方法

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
    time.sleep(1)
    count += 1
    print('worker running')

class MyThread(threading.Thread):

    def start(self):
        print('start-----------')
        super().start()   #调用父类的start方法
    def run(self):
        print('run-------------')
        super().run()

t = MyThread(target=worker,name='worker')
t.start()
#运行结果
start------------
run-----------
worker running

run方法

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
    time.sleep(1)
    count += 1
    print('worker running')

class MyThread(threading.Thread):

    def start(self):
        print('start-----------')
        super().start()   #调用父类的start方法
    def run(self):
        print('run-------------')
        super().run()

t = MyThread(target=worker,name='worker')
t.run()
#运行结果
run-------------
worker running

start()方法会调用run()方法，而run（）方法可以运行函数。
这两个方法看是功能重复了，name留一个方法就可以了，是这样吗？

start和run的区别

在线程函数中，增加打印线程名字的语句，看看能看到什么信息

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
    time.sleep(1)
    count += 1
    print('worker running')
    print(threading.current_thread().name)

class MyThread(threading.Thread):

    def start(self):
        print('start-----------')
        super().start()   #调用父类的start方法
    def run(self):
        print('run-------------')
        super().run()

t = MyThread(target=worker,name='worker')
t.start()
#t.run()   分别执行start和run方法，看看区别

使用start方法启动线程，启动了一个新的线程，名字叫做worker，但是使用run方法，并没有启动新线程，就是在主线程中调用了一个普通的函数而已。

因此，启动线程请使用start方法，才能启动多个线程

多线程

顾名思义，一个进程中如果有多个线程，就是多线程，实现一种并发

import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            break
    time.sleep(1)
    count += 1
    print('worker running')
    print(threading.current_thread().name，threading.current_thread().ident)

class MyThread(threading.Thread):

    def start(self):
        print('start-----------')
        super().start()   
    def run(self):
        print('run-------------')
        super().run()

t1 = MyThread(target=worker,name='worker1')
t2 = MyThread(target=worker,name='worker2')

t1.start()
t1.start()
#t1.run()
#t2.run()

可以看出start方法worker1和worker2交替执行

而使用run方法没有开新线程，就是普通的函数调用那个，执行完t1.run（），然后执行t2.run(),这就不是多线程

当start（）方法启动线程后，进程内有多个活动的线程并行的工作，就是多线程

一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程。一个进程至少有一个主线程，其他线程称为工作线程

线程安全

IPython中演示，python命令行，pycharm都不能演示出效果

import threading

def woker():
    for x in range(100):
        print('{} is running'.format(threading.current_thread().name))

for x in range(1,5):
    name = 'worker{}'.format(x)
    t = threading.Thread(target=worker,name=name)
    t.start()

运行以上代码，查看运行结果可以发现很多字符串打在了一起，不应该是一行行打印吗？这是为什么呢？

这就说明print函数在执行过程中被线程切换打断了。print函数执行分两步，第一步打印字符串，第二部换行，就在这之间，发生了线程的切换，导致了这种情况，print函数是线程不安全的

线程安全：线程执行一段代码，不会产生不确定的结果，那这段代码就是线程安全

上例中，本以为print应该是打印文本之后紧跟着一个换行的，但是有时候确实好几个文本在一起，后面跟上换行，而且发生这种情况的时机不确定，所以，print函数不是线程安全函数

如果是这样，多线程编程时，print输出日志，不能保证一个输出一定后面立即换行，怎么办？

1.不让print打印换行

import threading

def woker():
    for x in range(100):
        print('{} is running'.format(threading.current_thread().name)，end='') #不让print函数换行打印

for x in range(1,5):
    name = 'worker{}'.format(x)
    t = threading.Thread(target=worker,name=name)
    t.start()

字符串是不可变类型，它可以作为一个整体不可分割输出，end=”就不让print输出换行了

2.使用logging

import threading

def woker():
    for x in range(100):
        logging.warning('{} is running'.format(threading.current_thread().name))

for x in range(1,5):
    name = 'worker{}'.format(x)
    t = threading.Thread(target=worker,name=name)
    t.start()

daemon线程和non-daemon线程

注意：这里的daemon不是Linux中的守护进程

进程靠线程执行代码，至少有一个主线程，其它线程是工作线程

主线程是第一个启动的线程

父线程：如果线程A中启动了一个线程B，A就是B的父线程

子线程：B就是A的子线程

Python中，构造线程的时候可以设置daemon属性，这个属性必须在start方法之前设置好

#源码Thread的__init__方法中
if daemon is not None：
    self._daemonic = daemon  #用户设定bool值

else:
    self._daemonic = current_thread().daemon
self._ident = None

线程daemon属性，如果设定就是用户的设置，否则就去当前线程的daemon值

主线程时non-daemon 线程，即daemon = False

import time
import threading

def foo():
    time.sleep(5)
    for i in range(20):
        print(i)

#主线程是non-daemon线程
t = threading.Thread(target=foo,daemon=False)
t.start()

print('Main Thread Exiting')

发现线程t依然执行，主线程已经执行完，但是一直等着线程 t
修改为 t = threading.Thread(target=foo,daemon=True)试一试
程序立即结束了，根本没有等线程t

名称	含义
daemon属性	表示线程是否是daemon线程，这个值必须在start（）之前设置，否者引发RuntimeError异常
isDaemon（)	是否是daemon线程
setDaemon()	设置为daemon线程，必须在start方法之前设置

总结：
线程具有一个daemon属性，可以显示设置为True或False，也可以不设置，取默认值None
如果不设置daemon，就取当前线程的daemon来设置它

主线程时non-daemon线程，即daemon= False

从主线程创建的所有线程不设置daemon属性，则都默认daemon = False,也就是non-daemon线程

Python程序在没有活着的non-daemon线程运行时退出，也就是剩下的只能是daemon线程，主线程才能退出，否则主线程只能等待。

思考下面的程序的输出时是什么？

import time
import threading

def bar():
    time.sleep(10)
    print('bar')

def foo():
    for i in range(20):
        print(i)

    t =threading.Thread(target=bar,daemon=False)
    t.start()

#主线程是non-daemon线程
t= threading.Thread(target=foo,daemon=True)
t.start()

print('Main Thread Exiting')

上例中，会不会输出bar这个字符串？如果没有，如何修改才能打印出来呢？

time。sleep（2）
print('Main Thread Exiting')

在主线程print函数前加个延时语句

再看一个例子，看看主线程合适结束daemon线程

imprt time
import threading

def foo():
    for i in range(10):
    print(i)
    time.sleep(1)

t = threading.Thread(target=foo,args=(10,),daemon=True)  #调换10和20看看效果
t2.start()

t2 = threading.Thread(target=foo,aegs=(20,),daemon=False)

time.sleep(2)
print('Main Thread Exiting')

上例说明，如果有non-daemon线程的时候，主线程退出时，也不会结束所有的daemon，直到所有non-daemon线程全部结束，如果还有daemon线程，主线程需要要退出时，会结束所有daemon线程，退出

join方法

先看一个简单的例子，看看效果

import time
import threading

def foo(n):
    for i in range(n):
        print(i)
        time.sleep(1)

t1 = threading.Thread(target=foo,args=(10,),daemon=True)
t1.start()
t1.join()  #设置join，取消join对比一下

print('Main Thread Exiting')

使用了join方法后，daemon线程执行完了，主线程才退出了

join（timeout=None),是县城的标准方法之一

一个线程中调用另一个线程的join方法，调用者将被阻塞，直到被调用线程结束

timeout参数指定调用者需要等待多久，没有设置超时时，就一直等到被调用线程执行完结束

调用谁的join方法，就是join谁，就要等谁

daemon线程应用场景

简单来说，本来并没有daemon线程，为了简化程序员的工作，让他们不用去记录和管理那些后台线程，创造了以个daemon线程的概念，这个概念唯一的作用就是，当你把一个线程设置为daemon线程，它会随着主线程的退出而退出

主要应用场景：

1.后台任务，如发送心跳包、监控，这种场景最多

2.主线程工作采用那个用的线程，如主线程中维护着公共的资源，主线程已经清理了，准备退出，而工作线程使用这些资源，那工作也就没有意义了，一起退出最合适

3.随时可以被终止的线程

如果主线程退出，想所有其它工作线程一起退出，就是用daemon=True来创建线程
比如，开启一个线程定时判断WEB服务是否正常工作，主线程退出，工作线程也就没有必要了，应该随着主线程退出一起退出。这种daemon线程一旦创建，就可以忘记它了，只用关心主线程什么时候退出就行了

daemon线程简化了程序员手动关闭线程的工作

如果non-daemon线程A中，对另一个daemon线程B使用了join方法，那么线程B设置成daemon线程就没有什么意义了，因为non-daemon线程A总是要等待B

如果在一个daemon线程C中，对另一个daemon线程D使用了join方法，只能说明C要等待D，主线程退出，C和D不管是否结束，也不管它们谁等谁，都要被强制结束

举例

import time
import threading

def bar():
    while True:
        time.sleep(1)
        print('bar')

def foo():
    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
    t2 = threading.Thread(target=bar)
    t2.start()
    print("t2's daemon = {}".fromat(t2.isDaemon()))

t1 = threading.Thread(target=foo,daemon=True)
t1.start()

time.sleep(2)
print('Main Thread Exiting')

上例，只要主线程退出，2个工作线程都结束

可以使用join，让线程结束不了，怎么做？

import time
import threading

def bar():
    while True:
        time.sleep(1)
        print('bar')

def foo():
    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
    t2 = threading.Thread(target=bar)
    t2.start()
    print("t2's daemon = {}".fromat(t2.isDaemon()))
    t2.join() #

t1 = threading.Thread(target=foo,daemon=True)
t1.start()
t1.join() #

time.sleep(2)
print('Main Thread Exiting')

threading.local类

import time
import threading

def worker():
    x = 0
    for i in range(100):
        time.sleep(0.0001)
        x += 1
    print(threading.current_thread(),x)

for i in range(10):
    threading.Thread(target=worker).start()

上例使用多线程，每个线程完成不同的计算任务，x是局部变量，能否改造成使用全局变量完成

import time
import threading

class A：
    def __init__(self):
        self.x = 0

global_data = A()

def worker():
    global_data.x = 0

    for i in range(100):
        time.sleep(0.0001)
        global_data.x  += 1
    print(threading.current_thread(),global_data.x )

for i in range(10):
    threading.Thread(target=worker).start()

运行还是上面的代码可以看出上例虽然使用了全局变量，但是线程之间互相干扰，导致了错误的结果。

能不能使用全局变量，还能保证每个线程使用不同的数据呢？

Python提供threading.local类，将这个类实例化得到一个全局对象，但是不同线程使用这个对象储存的数据其他线程看不见

import time
import threading

class A：
    def __init__(self):
        self.x = 0

global_data = threading.local()

def worker():
    global_data.x = 0

    for i in range(100):
        time.sleep(0.0001)
        global_data.x  += 1
    print(threading.current_thread(),global_data.x )

for i in range(10):
    threading.Thread(target=worker).start()

结果显示和使用局部变量的效果一样

再看看threading.local的例子

import threading

X = 'abc'
ctx = threading.local()
ctx.x = 123

print(ctx,type(ctx),ctx.x)

def worker():
    print(X)
    print(ctx)
    print(ctx.x)
    print('working')

worker()
print('-----------')
threading.Thread(target=worker).start()   #另起一个线程

从运行结果来看，另起一个线程打印ctx.x出错了

AttributeError: '_thread._local' object has no attribute 'x'

但是，ctx打印没有出错，说明看到了ctx，但是ctx中的x看不到，这个x不能跨线程

threading.local类构建了一个大字典，其元素时每个线程实例的地址为key和线程对象引用线程单独的字典的映射，如下：

{id(Thrread) -> (ref(Thread),thread-local dict)}

通过threading.local实例就可在不同的线程中，安全地使用线程独有的数据，做到了线程间数据隔离，如同本地变量一样安全

定时器Timer/延迟执行

threading.Timer继承自Thread,这个类用来定义多久执行一个函数

class thread.Timer(interval,function,arg=None,kwargs=None)

start方法执行之后，Timer对象会处于等待状态，等待了interval之后，开始执行function函数

如果在执行函数之前的等待阶段，使用了cancel方法，就会跳过执行函数结束

import threading
import logging
import time

FORMAT = '%(asctime)s %(threadname)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT,level=logging.INFO)

def worker():
    logging.info('in worker')
    time.sleep(2)

t = threading.Timer(5,worker)
t.setName('worker1')
t.start()
print(threading.enumerate())
t.cancel()   #取消，可以注释这一句看看如何定时执行
tim.sleep(1)
print(threading.enumerate())

如果线程worker函数已经开始执行，cancel就没有任何效果了

总结：

Timer是线程Thread的子类，就是线程类，具有线程的能力和特征

他的实例时能够延时执行目标函数的线程，在真正执行函数之前，都可以cancel它

import threading
import logging
import time

FORMAT = '%(asctime)s %(threadname)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT,level=logging.INFO)

def worker():
    logging.info('in worker')
    time.sleep(2)

t = threading.Timer(5,worker)
t.setName('worker1')
t.cancel() #提前取消
t.start()
print(threading.enumerate())

tim.sleep(8)
print(threading.enumerate())