本文共 9774 字，大约阅读时间需要 32 分钟。

1. 并发

1.1 并发的基本概念

1.1.1 并发和并行的区别

并行，parallel

同时做某些事，可以互不干扰的同一时刻做几件事。 并发，concurrency 也是同时做某些事，但是强调，一个时段内有事情要处理。

1.1.2 并发的解决

食堂打饭模型：

队列、缓冲区（buffering）

争抢

预处理（缓存）

并行（水平扩展思想）

提速（垂直扩展思想）

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

消息中间件

  常见的消息中间件有RabbitMQ、ActiveMQ（Apache）、RocketMQ（阿里Apache）、kafka（Apache）等

2. 进程和线程

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

  进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。Linux进程有父进程、子进程，Windows的进程是平等关系。

2.1 进程和程序的关系

  程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程，进程中存放着指令和数据（资源），它也是线程的容器。

  线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。在许多系统中，创建一个线程比创建一个进程快10-100倍。

2.1.1 进程与线程的理解

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

进程就是独立的国家，进程间不可以随便的共享数据。 线程就是省份，同一个进程内线程可以共享进程的资源，每一个线程拥有自己独立的堆栈。（线程之间的数据也是不能共享的）

2.2 线程的状态

2.2.1 python中的进程和线程

进程会启动一个解释器进程，线程共享一个解释器进程。

2.3 python的线程开发

python的线程开发使用标准库threading

2.3.1 Thread类

def __init__(self, group=None, target=None, name=None, args=(), kwargs={
   }, *, daemon=None)

import threading# 最简单的线程程序def worker():	print("I'm working")	print('Fineshed')t = threading.Thread(target=worker, name='worker') # 线程对象t.start() # 启动

  通过threading.Thread创建一个线程对象，target是目标函数，name可以指定名称。但是线程没有启动，需要调用start方法。线程之所以执行函数，是因为线程中就是执行代码的，而最简单的封装就是函数，所以还是函数调用。函数执行完，线程也就退出了。

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

import threadingimport timedef worker():	while True:		time.sleep(1)		print("I'm working")		print('Fineshed')t = threading.Thread(target=worker, name='worker') # 线程对象t.start() # 启动

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

1. 线程函数内的语句执行完毕
2. 线程函数中抛出未处理的异常
   python的线程没有优先级、没有线程组的概念，也不能被销毁、停止、挂起，那也就没有恢复、中断了。

线程传参:

import threadingimport timedef add(x, y):	print('{} + {} = {}'.format(x, y, x + y, threading.current_thread().ident))thread1 = threading.Thread(target=add, name='add', args=(4, 5)) # 线程对象thread1.start() # 启动time.sleep(2)thread2 = threading.Thread(target=add, name='add', args=(5,), kwargs={
   'y': 4}) # 线程对象thread2.start() # 启动time.sleep(2)thread3 = threading.Thread(target=add, name='add', kwargs={
   'x': 4, 'y': 5}) # 线程对象thread3.start() # 启动

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

threading的属性和方法:

active_count、enumerate()方法返回的值还包括主线程。

import threadingimport timedef show_thread_info():    print("current_thread = {}".format(threading.current_thread()))    print("main thread = {}".format(threading.main_thread()))    print("active_count = {}".format(threading.active_count()))def worker():    count = 0    show_thread_info()    while True:        if count > 3:            break        time.sleep(1)        print("I'm working")        count += 1t = threading.Thread(target=worker, name='worker')  # 线程对象show_thread_info()t.start()  # 启动print('==End==')"""\current_thread = <_MainThread(MainThread, started 1744)>main thread = <_MainThread(MainThread, started 1744)>active_count = 1current_thread = 
   
    ==End==main thread = <_MainThread(MainThread, started 1744)>active_count = 2I'm workingI'm workingI'm workingI'm working"""
   

Thread实例的属性和方法:

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

注意：每一个线程必须且只能执行start()方法一次

2.4 多线程

  顾名思义，多个线程，一个进程中如果有多个线程，就是多线程，实现一种并发。一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程。一个进程至少有一个主线程，其他线程称为工作线程。

2.4.1 线程安全

线程安全

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

import threadingdef worker():    for x in range(100):        print('{} is running'.format(threading.current_thread().name))for i in range(5):    name = 'worker{}'.format(i + 1)    t = threading.Thread(target=worker, name=name)    t.start()

注意：IPython中演示、python命令行、pycharm都不能演示出效果

看代码，应该是一行行打印，但是很多字符串打在了一起，为什么？   说明，print函数被打断了，被线程切换打断了。print函数分两步，第一步打印字符串，第二步换行，就在这之间，发生了线程的切换。这说明print函数是线程不安全的。 那么问题来了，多线程编程的时候，print输出日志，不能保证一个输出一定后面立即换行了，怎么办？

1. 不让print打印换行，直接将end设置为空

import threadingdef worker():    for x in range(100):        print('{} is running'.format(threading.current_thread().name), end='')for i in range(5):    name = 'worker{}'.format(i + 1)    t = threading.Thread(target=worker, name=name)    t.start()

2. 使用logging
     标准库里面的logging模块，日志处理模块，线程安全，生成环境代码都使用logging

import threadingimport loggingFORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'  # 注意%后不能有空格，C语言风格logging.basicConfig(format=FORMAT, level=logging.INFO)def worker():    for x in range(100):        logging.info('{} is running'.format(threading.current_thread().name), end='')for i in range(5):    name = 'worker{}'.format(i + 1)    t = threading.Thread(target=worker, name=name)    t.start()

2.4.2 daemon线程和non-daemon线程

注意：这里的daemon不是linux中的守护线程

  进程靠线程执行代码，至少有一个主线程，其它线程是工作线程。主线程是第一个启动的线程。父线程：如果线程A中启动了一个线程B，A就是B的父线程。子线程：B就是A的子线程。Python中，构造线程的时候，可以设置daemon属性，这个属性必须在start方法前设置好。   线程daemon属性，如果设定就是用户的设置，否则就取当前线程的daemon值。主线程是non-daemon线程，即daemon = False。

import timeimport threadingdef foo():    time.sleep(2)    for i in range(3):        print(i)# 主线程是non-daemon线程t = threading.Thread(target=foo, daemon=False)t.start()print('Main Thread Exiting')"""\Main Thread Exiting012"""

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

总结   线程具有一个daemon属性，可以显示设置为True或False，也可以不设置，则取默认值None。如果不设置daemon，就取当前线程daemon来设置它。主线程是non-daemon线程，即daemon = False。从主线程创建的所有线程的不设置daemon属性，则默认都是daemon = False，也就是non-daemon线程。Python程序在没有活着的non-daemon线程运行时退出，也就是剩下的只能是daemon线程，主线程才能退出，否则主线程就只能等待。

import timeimport threadingdef foo(n):    for i in range(n):        print(i)        time.sleep(1)t1 = threading.Thread(target=foo, args=(2,), daemon=True)  # 调换10和20看看效果t1.start()t2 = threading.Thread(target=foo, args=(5,), daemon=False)  # 主线程会等到此线程结束再退出t2.start()time.sleep(2)  # 主线程睡2秒钟print('Main Thread Exiting')"""\0011Main Thread Exiting234"""

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

2.4.3 join方法

先来看一个简单的例子

import timeimport threadingdef 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()  # 会让主线程等t1这个工作线程，主线程会卡在这里，直到t1工作线程结束print('Main Thread Exiting')  # 有了join方法后，此语句会最后打印

  使用了join方法后，daemon线程执行完了，主线程才退出了。join(timeout=None)，是线程的标准方法之一。一个线程中调用另一个线程的join方法，调用者将被阻塞，直到被调用线程终止。一个线程可以被join多次。timeout参数指定调用者等待多久，没有设置超时，就一直等到被调用线程结束。调用谁的join方法，就是join谁，就要等谁。

2.4.4 daemon线程应用场景

  简单来说就是，本来并没有 daemon thread，为了简化程序员的工作，让他们不用去记录和管理那些后台线程，

创造了一个 daemon thread 的概念。这个概念唯一的作用就是，当你把一个线程设置为 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 timeimport threadingdef bar():    while True:        time.sleep(1)        print('bar')def foo():    print("t1's daemon = {}".format(threading.current_thread().isDaemon()))    t2 = threading.Thread(target=bar)  # 默认取t1线程设置的daemon值，即True,但是有join方法,所以t1线程会等待t2线程    t2.start()    print("t2's daemon = {}".format(t2.isDaemon()))    t2.join(2)  # 会死循环，因为t1线程一直要等t2线程，而t2线程函数是死循环，可以设置等待时间t1 = threading.Thread(target=foo, daemon=True)t1.start()t1.join()  # 主线程会卡在这里time.sleep(3)  # 会让主线程沉睡3秒，会继续执行线程t2print('Main Thread Exiting')"""\t1's daemon = Truet2's daemon = TruebarbarbarbarbarMain Thread Exiting"""

2.4.5 threading.local类

import threadingimport time# 局部变量实现def worker():    x = 0    for i in range(100):        time.sleep(0.0001)        x += 1    print(threading.current_thread(), x)for _ in range(10):    threading.Thread(target=worker).start()

  上例使用多线程，每个线程完成不同的计算任务。x是局部变量，可以看出每一个线程的x是独立的，互不干扰的，为什么？每个线程函数都需要压栈，并且都是独立的，x为局部变量就是说每个线程函数都使用局部的x，所以会互不干扰

那么问题来了，能否改造成使用全局变量完成？   因为多线程之间相互干扰，会导致出现不期望的结果。那么能不能使用全局对象，还能保持每个线程使用不同的数据呢？python提供了threading.local类，将这个类实例化得到一个 全局对象，但是不同的线程使用这个对象存储的数据其他线程看不到。

import threadingimport time# 全局对象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 _ in range(5):    threading.Thread(target=worker).start()"""\
   
     100
    
      100
     
       100
      
        100
       
         100"""
       
      
     
    
   

再来看一个threading.local的例子

import threadingX = 'abc'ctx = threading.local()ctx.x = 123print(ctx, type(ctx), ctx.x)def worker():    print(X)    print(ctx)    print(ctx.x)    print('working')worker()  # 普通函数调用，注意此时是在主线程中print()threading.Thread(target=worker).start()# 开启一个新的线程,此时线程函数worker中的ctx.x就会报错，因为此线程看不到主线程中ctx.x的值# AttributeError: '_thread._local' object has no attribute 'x'

  从运行结果来看，另起一个线程打印ctx.x出错了。AttributeError: ‘_thread._local’ object has no attribute ‘x’，但是，ctx打印没有出错，说明看到ctx，但是ctx中的x看不到，这个x不能跨线程。

threading.local类构建了一个大字典，存放所有线程相关的字典，定义如下： { id(Thread) -> (ref(Thread), thread-local dict) }   每一线程实例的id为key，元组为value。value中2部分为，线程对象引用，每个线程自己的字典。

2.4.6 定时器Timer/延迟执行

threading.Timer继承自Thread，这个类用来定义延迟多久后执行一个函数。

class threading.Timer(interval, function, args=None, kwargs=None) start方法执行之后，Timer对象会处于等待状态，等待了interval秒之后，开始执行function函数的。

import threadingimport loggingimport timeFORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"logging.basicConfig(level=logging.INFO, format=FORMAT)def worker():    logging.info('in worker')    time.sleep(2)  # 2秒之后当前线程接结束，主线程也结束了count = 0t = threading.Timer(4, worker)t.setName('timer')# t.cancel()  # 此位置会取消线程，线程timer都没有机会启动t.start()# t.cancel()  # 此位置会取消线程函数的执行，注意线程timer已经启动了while count < 3:    print(threading.enumerate())  # 列出当前活着的线程    time.sleep(1)    count += 1

  Timer提供了cancel方法，用来取消一个未执行的函数，如果上面例子中worker函数已经开始执行，cancel就没有任何效果了。

总结:   Timer是线程Thread的子类，就是线程类，具有线程的能力和特征。它的实例是能够延时执行目标函数的线程，在真正执行目标函数之前，都可以cancel它。cancel方法本质使用Event类实现。这并不是说，线程提供了取消的方法。

转载地址：http://xpfvi.baihongyu.com/