1. 操作系统基本知识，进程，线程

CPU是计算机的核心，承担了所有的计算任务；

操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；那么操作系统是如何进行任务调度的呢？

1.1 任务调度

大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制暂停去执行下一个任务，被暂停的任务就处于就绪状态等待下一个属于它的时间片的到来。这样每个任务都能得到执行，由于CPU的执行效率非常高，时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，这也就是我们所说的并发(别觉得并发有多高深，它的实现很复杂，但它的概念很简单，就是一句话：多个任务同时执行)。多任务运行过程的示意图如下：

注意：当一个任务得到CPU时，相关的资源必须已经就位，然后CPU开始执行，除了CPU以外的所有就构成了这个任务的执行环境，就是所谓的程序上下文，CPU每一次任务的切换都需要保存程序的上下文，这个上下文就是下一次CPU临幸是的环境；

所以任务的轮转方法为：先加载程序A的上下文，然后开始执行A，保存程序A的上下文，调入下一个要执行的程序B的程序上下文，然后开始执行B,保存程序B的上下文。。。。

1.2 进程

说到进程，需要先提一下程序

应用程序是用于实现某种功能的一组指令的有序集合（只不过是磁盘中可执行的二进制（或者其他类型）的数据）；应用程序运行于操作系统之上（只有将程序装载到内存中，系统为它分配了资源并被操作系统调用的时候才开始它们的生命周期，即运行）

进程（有时候被称为重量级进程）是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位（不是最小单位），是应用程序运行的载体；

每一个进程都有自己的地址空间、内存、数据栈以及其他记录起运行轨迹的辅助数据。操作系统管理其上运行的所有进程，并为这些进程公平的分配时间、进程也可以通过fork和spawn操作类完成其他的任务。不过各个进程有自己的内存空间、数据栈等，所以只能使用进程间通讯（interprocess communication， IPC），而不能直接共享信息。

我们再看一下wiki上的解释：

An executing instance of a program is called a process.

Each process provides the resources needed to execute a program. A process has a virtual address space, executable code, open handles to system objects, a security context, a unique process identifier, environment variables, a priority class, minimum and maximum working set sizes, and at least one thread of execution. Each process is started with a single thread, often called the primary thread, but can create additional threads from any of its threads.

1）进程的组成和特性

进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。

进程的特性：

动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；

并发性：任何进程都可以同其他进程一起并发执行；

独立性：进程是系统进行资源分配和调度的一个独立单位；

结构性：进程由程序、数据和进程控制块三部分组成。

2）进程和程序的区别与联系

a）程序只是一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体。而进程则不同，它是程序在某个数据集上的执行。进程是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映了一个程序在一定的数据集上运行的全部动态过程。

b）进程和程序并不是一一对应的，一个程序执行在不同的数据集上就成为不同的进程，可以用进程控制块来唯一地标识每个进程。而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系，既使是执行不同的数据的程序，他们的指令的集合依然可以是一样的，所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说，一个进程肯定有一个与之对应的程序，而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。

c）进程还具有并发性和交往性，这也与程序的封闭性不同。进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 。

3）为什么还要线程

进程有很多优点，它提供了多道编程，让我们感觉我们每个人都拥有自己的CPU和其他资源，可以提高计算机的利用率。很多人就不理解了，既然进程这么优秀，为什么还要线程呢？其实，仔细观察就会发现进程还是有很多缺陷的，比如：

a）进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。

b）进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

c）程序变得越来越复杂，对CPU的要求也越来越高（对多个任务之间上下文切换的效率要求越来越高），而进程之间的切换开销较大，无法满足需求

于是就有了线程

1.3 线程

首先，早期操作系统没有线程的概念，那时，进程不但是拥有资源和独立运行的最小单位，也是程序执行和任务调度的最小单位；但是随着程序变得越来越复杂，系统对多个任务之间上下文切换的效率要求越来越高，而进程之间的切换开销较大，无法满足需求。于是发明了线程；

线程（轻量级进程）是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元（比进程更小的能独立运行的基本单位），是CPU处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)，每条线程并行执行不同的任务。

线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)；

一个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。而进程由内存空间(代码、数据、进程空间、打开的文件)和一个或多个线程组成。

线程有开始、顺序执行和结束三部分。它有一个自己的指令指针，记录自己运行到什么地方。线程的运行可能被占用（中断），或者暂时的被挂起（睡眠），让其他的线程运行，这叫做让步。一个进程中的各个线程之间共享同一片数据空间，所以线程之间可以比进程之间更加方便的共享数据以及相互通讯。

Wiki上对线程的定义：

A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.

Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.

If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.

Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.

On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.

Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.

Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).

1）进程与线程的关系

线程是程序执行的最小单位，是CPU处理器调度和分派的基本单位；而进程是操作系统分配资源的最小单位；一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线，某进程内的线程在其它进程不可见；

a）划分尺度:线程更小，所以多线程程序并发性更高；一个线程可以创建和撤销另一个线程；

b）资源分配：进程是资源分配的基本单位，同一进程内各个线程共享其资源(如打开文件和信号)；

c）地址空间：进程拥有独立的地址空间，同一进程内各个线程共享其内存空间(包括代码段、数据集、堆等)；

d）处理器调度和切换：线程是处理器调度的基本单位；线程上下文切换比进程上下文切换要快得多，线程开销比进程小很多；

e）执行：线程不能单独执行，必须组成进程，一个进程至少有一个主线程。简而言之,一个程序至少有一个进程,一个进程至少有一个线程；

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

线程与进程共享关系示意图：

wiki上关于进程线程关系的解释：

a）Threads share the address space of the process that created it; processes have their own address space.

b）Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.

c）Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.

d）New threads are easily created; new processes require duplication of the parent process.

e）Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.

f）Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process does not affect child processes.

1.4 多线程与多核

线程一般都是并发执行的。正是由于这种并发和数据共享的机制使得多个任务合作变为可能。实际上，在单CPU的系统中，真正的并发是不可能的，每个线程会被安排成每次只运行一小会儿，然后就把CPU让出来，让其他的线程去运行。那么，如果有多颗CPU，准确的说是多个核心呢？

1）CPU

我们经常看到CPU的参数：双核心四线程，四核心四线程等等；到底是什么意思呢？

多核(心)处理器是指在一个处理器上集成多个运算核心从而提高计算能力，每一个处理核心对应一个内核线程。那双核心四线程是怎么回事呢？因为使用了超线程技术，采用超线程技术（HT）将一个物理处理核心模拟成两个逻辑处理核心，对应两个内核线程。

我们来看几个CPU常用概念：

a）物理CPU ：实际Server中插槽上的CPU个数，物理cpu数量；

b）CPU核心数：CPU的核心数是指物理上，也就是硬件上存在着几个核心。比如，双核就是包括2个相对独立的CPU核心单元组，四核就包含4个相对独立的CPU核心单元组。

c） 逻辑CPU：逻辑CPU数量=物理cpu数量 * 每颗CPU的核心数*2(如果支持并开启HT，HT是intel的超线程技术)

d）线程数（内核线程）：线程数就是逻辑CPU数目

e）查看CPU信息

-- windows：

cmd命令中输入“wmic”，然后在出现的新窗口中输入“cpu get *”即可查看物理CPU数、CPU核心数、线程数。其中：

　　Name:表示物理CPU数
　　NumberOfCores：表示CPU核心数
　　NumberOfLogicalProcessors：表示CPU线程数

-- Linux：

Linux下top查看的CPU也是逻辑CPU个数

　　#逻辑CPU个数

　　cat /proc/cpuinfo | grep "processor" | sort –u | wc -l

　　#物理CPU个数：

　　cat /proc/cpuinfo | grep "physical id" | sort -u | wc -l

　　#CPU核心数

　　grep 'core id' /proc/cpuinfo | sort -u | wc -l

2）内核进程和用户进程

上面讲到逻辑CPU数目就是线程数，这个线程指的是内核线程，到底什么是内核线程呢？

内核线程（Kernel Thread， KLT）就是直接由操作系统内核支持的线程，这种线程由内核来完成线程切换，内核通过操作调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。一般一个处理核心对应一个内核线程。

程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程（Light Weight Process，LWP），轻量级进程就是我们通常意义上所讲的线程(我们在这称它为用户线程)，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。用户线程与内核线程的对应关系有三种模型：一对一模型、多对一模型、多对多模型；

在这以4个内核线程、3个用户线程为例对三种模型进行说明：

a）一对一模型

对于一对一模型来说，一个用户线程就唯一地对应一个内核线程(反过来不一定成立，一个内核线程不一定有对应的用户线程)。

线程之间的并发是真正的并发。一对一模型使用户线程具有与内核线程一样的优点，一个线程因某种原因阻塞时其他线程的执行不受影响；此处，一对一模型也可以让多线程程序在多处理器的系统上有更好的表现。

但一对一模型也有两个缺点：1.许多操作系统限制了内核线程的数量，因此一对一模型会使用户线程的数量受到限制；2.许多操作系统内核线程调度时，上下文切换的开销较大，导致用户线程的执行效率下降。

b）多对一模型

多对一模型将多个用户线程映射到一个内核线程上，线程之间的切换由用户态的代码来进行，因此相对一对一模型，多对一模型的线程切换速度要快许多；此外，多对一模型对用户线程的数量几乎无限制。但多对一模型也有两个缺点：1.如果其中一个用户线程阻塞，那么其它所有线程都将无法执行，因为此时内核线程也随之阻塞了；2.在多处理器系统上，处理器数量的增加对多对一模型的线程性能不会有明显的增加，因为所有的用户线程都映射到一个处理器上了。

c）多对多模型

多对多模型结合了一对一模型和多对一模型的优点，将多个用户线程映射到多个内核线程上。多对多模型的优点有：1.一个用户线程的阻塞不会导致所有线程的阻塞，因为此时还有别的内核线程被调度来执行；2.多对多模型对用户线程的数量没有限制；3.在多处理器的操作系统中，多对多模型的线程也能得到一定的性能提升，但提升的幅度不如一对一模型的高。

在现在流行的操作系统中，大都采用多对多的模型。

关于进程，线程，这里介绍的还是简单，建议找一本关于操作系统的书好好研读一番，现在我们回归到Python

2. Python多线程与GIL

首先，让我们看一个问题，运行下面这段python代码，看看CPU占用率多少？

def dead_loop():

    while True:

        pass

dead_loop()

因为，我的电脑是双核四线程，所以这个死循环的CPU使用率是由25%

那么如果我使用多线程，运行两个线程，这两个线程的CPU利用率不是就到50%了吗！试一下：

import threading

def dead_loop():

    while True:

        pass

# 新起一个死循环线程

t = threading.Thread(target=dead_loop)

t.start()

# 主线程也进入死循环

dead_loop()

但是，实际运行结果还是25%；为什么会这样呢？幕后黑手就是GIL

2.1 GIL

我们先看一下官方对GIL的解释

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

简单的一句话包含了很多信息；

a）在Python众多解释器中，只有Cpython才有GIL，JPython就没有；因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。明确一点，GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念，Python完全可以不依赖于GIL;

看一下CPython的源代码

static PyThread_type_lock interpreter_lock = ; /* This is the GIL */

这一行代码摘自 ceval.c —— CPython 2.7 解释器的源代码，Guido van Rossum 的注释”This is the GIL“ 添加于2003 年，但这个锁本身可以追溯到1997年他的第一个多线程 Python 解释器。在 Unix系统中，PyThread_type_lock 是标准 C  mutex_t 锁的别名。当 Python 解释器启动时它初始化：

void

PyEval_InitThreads(void)

{

    interpreter_lock = PyThread_allocate_lock();

    PyThread_acquire_lock(interpreter_lock);

}

解释器中的所有 C 代码在执行 Python 时必须保持这个锁。

b）GIL是一把互斥锁

Python代码的执行由Python虚拟机（也叫解释器主循环）来控制，而对Python虚拟机的访问由GIL（全局解释器锁）控制，GIL保证了在任意时刻，只有一个线程在解释器中运行，就像单CPU系统运行多线程一样，内存中可以存放多个程序，但在任意时刻，只有一个线程在解释器中运行；

c）GIL是历史遗留问题，为了解决线程安全的简单粗暴做法

多线程编程可以更有效地利用多核处理器，但是随之带来的就是线程间数据一致性和状态同步的困难（线程安全）；多核 CPU 在 1990 年代还属于类科幻，Guido van Rossum 在创造 python 的时候，也想不到他的语言有一天会被用到很可能 1000＋ 个核的 CPU 上面，一个全局锁搞定多线程安全在那个时代应该是最简单经济的设计了。简单而又能满足需求，那就是合适的设计（对设计来说，应该只有合适与否，而没有好与不好）。

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

d）GIL的执行机理

记住一个原则：“一个线程运行 Python ，而其他 N 个睡眠或者等待 I/O.”（One thread runs Python, while others sleep or await I/O）

多线程环境中，python虚拟机按以下方式执行：

1. 设置GIL
2. 切换到一个线程去执行
3. 运行
   • 指定数量的字节码指令(python2为1000字节指令)或运行了执行时间（python3为15ms）---抢占式多任务处理
   • 线程主动让出控制（可以调用time.sleep(0)) -------协同式多任务处理
4. 把线程设置完睡眠状态
5. 解锁GIL
6. 再次重复以上步骤

对所有面向 I/O 的(会调用内建的操作系统 C 代码的)程序来说，GIL 会在这个 I/O 调用之前被释放， 以允许其它的线程在这个线程等待 I/O 的时候运行。 如果某线程并未使用很多 I/O 操作，它会在自己的时间片内一直占用处理器（和 GIL）。也就是说，I/O 密集型（程序大量时间花费在等待I/O操作，CPU总是闲置，在10%左右（如：网络请求socket））的 Python 程序比计算密集型（程序线性执行，大量占用CPU，总是接近100%（如：正则匹配替换大量文本））的程序更能充分利用多线程环境的好处。

线程何时切换？一个线程无论何时开始睡眠或等待网络 I/O，其他线程总有机会获取 GIL 执行 Python 代码。这是协同式多任务处理。CPython 也还有抢占式多任务处理。如果一个线程不间断地在 Python 2 中运行 1000 字节码指令，或者不间断地在 Python 3 运行15 毫秒，那么它便会放弃 GIL，而其他线程可以运行。把这想象成旧日有多个线程但只有一个 CPU 时的时间片。现在，将具体讨论这两种多任务处理。

协同式多任务处理

当一项任务比如网络 I/O启动，而在长的或不确定的时间，没有运行任何 Python 代码的需要，一个线程便会让出GIL，从而其他线程可以获取 GIL 而运行 Python。这种礼貌行为称为协同式多任务处理，它允许并发；多个线程同时等待不同事件。

def do_connect():

    s = socket.socket()

    s.connect(('python.org', 80))  # drop the GIL

for i in range(2):

    t = threading.Thread(target=do_connect)

    t.start()

/* s.connect((host, port)) method */

static PyObject *

sock_connect(PySocketSockObject *s, PyObject *addro)

{

    sock_addr_t addrbuf;

    int addrlen;

    int res;

    /* convert (host, port) tuple to C address */

    getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen);

    Py_BEGIN_ALLOW_THREADS

    res = connect(s->sock_fd, addr, addrlen);

    Py_END_ALLOW_THREADS

    /* error handling and so on .... */

}

PyThread_release_lock(interpreter_lock);

from multiprocessing import Process, freeze_support

def dead_loop():

    while True:

        pass

if __name__ == '__main__':

    freeze_support()

    #fork一个子进程

    t = Process(target=dead_loop)

    t.start()

    dead_loop()

 import threading

 from time import sleep, ctime

 #每个线程执行的时间

 loop_time_list = (4, 2)

 #线程执行的函数

 def loop(loop_mem, loop_time):

     print('start loop %s at %s' % (loop_mem, ctime()))

     sleep(loop_time)

     print('loop %s done at %s' % (loop_mem, ctime()))

 def main():

     print('Programming start at: %s' % ctime())

     threads = []

     #线程数

     loop_num = range(len(loop_time_list))

     #create threads

     for i in loop_num:

         t = threading.Thread(target=loop, args=(i, loop_time_list[i],))

         threads.append(t)

     #start threads

     for i in loop_num:

         threads[i].start()

     print('all done at: %s' % ctime())

 if __name__ == '__main__':

     main()

 import threading

 from time import sleep, ctime

 #每个线程执行的时间

 loop_time_list = (4, 2)

 class MyThread(threading.Thread):

     def __init__(self, func, args):

         threading.Thread.__init__(self)

         self.func = func

         self.args = args

     def run(self):

         self.func(*self.args)

 #线程执行的函数

 def loop(loop_mem, loop_time):

     print('start loop %s at %s' % (loop_mem, ctime()))

     sleep(loop_time)

     print('loop %s done at %s' % (loop_mem, ctime()))

 def main():

     print('Programming start at: %s' % ctime())

     threads = []

     #线程数

     loop_num = range(len(loop_time_list))

     #create threads

     for i in loop_num:

         t = MyThread(loop, (i, loop_time_list[i]))

         threads.append(t)

     #start threads

     for i in loop_num:

         threads[i].start()

     print('all done at: %s' % ctime())

 if __name__ == '__main__':

     main()

 def run(self):

     """Method representing the thread's activity.

     You may override this method in a subclass. The standard run() method

     invokes the callable object passed to the object's constructor as the

     target argument, if any, with sequential and keyword arguments taken

     from the args and kwargs arguments, respectively.

     """

     try:

         if self._target:

             self._target(*self._args, **self._kwargs)

     finally:

         # Avoid a refcycle if the thread is running a function with

         # an argument that has a member that points to the thread.

         del self._target, self._args, self._kwargs

self._target = target

import threading

class MyThread(threading.Thread):

    def __init__(self,func,args=()):

        super(MyThread,self).__init__()

        self.func = func

        self.args = args

    def run(self):

        self.result = self.func(*self.args)

    def get_result(self):

        try:

            return self.result  # 如果子线程不使用join方法，此处可能会报没有self.result的错误

        except Exception:

            return None

def foo(a,b,c):

    time.sleep(1)

    return a*2,b*2,c*2

st = time.time()

li = []

for i in xrange(4):

    t = MyThread(foo,args=(i,i+1,i+2))

    li.append(t)

    t.start()

for t in li:

    t.join()  # 一定要join，不然主线程比子线程跑的快，会拿不到结果

    print(t.get_result())

et = time.time()

print(et - st)

import threading

from time import sleep, ctime

#每个线程执行的时间

loop_time_list = (4, 2)

#线程执行的函数

def loop(loop_mem, loop_time):

    print('start loop %s at %s' % (loop_mem, ctime()))

    sleep(loop_time)

    print('loop %s done at %s' % (loop_mem, ctime()))

def main():

    print('Programming start at: %s' % ctime())

    threads = []

    #线程数

    loop_num = range(len(loop_time_list))

    #create threads

    for i in loop_num:

        t = threading.Thread(target=loop, args=(i, loop_time_list[i]), )

        threads.append(t)

    #start threads

    for i in loop_num:

        threads[i].start()

    for i in loop_num:

        threads[i].join()

    print('all done at: %s' % ctime())

if __name__ == '__main__':

    main()

    for i in loop_num:

        threads[i].join(timeout=3)

 import threading

 from time import sleep, ctime

 #每个线程执行的时间

 loop_time_list = (4, 2)

 #线程执行的函数

 def loop(loop_mem, loop_time):

     print('start loop %s at %s' % (loop_mem, ctime()))

     sleep(loop_time)

     print('loop %s done at %s' % (loop_mem, ctime()))

 def main():

     print('Programming start at: %s' % ctime())

     threads = []

     #线程数

     loop_num = range(len(loop_time_list))

     #create threads

     for i in loop_num:

         t = threading.Thread(target=loop, args=(i, loop_time_list[i]), )

         threads.append(t)

     #将第一个线程（执行4s）设置为守护线程

     threads[0].setDaemon(True)

     #start threads

     for i in loop_num:

         threads[i].start()

     print('all done at: %s' % ctime())

 if __name__ == '__main__':

     main()

n = 0

def foo():

    global n

    n += 1

>>> import dis

>>> dis.dis(foo)

LOAD_GLOBAL              0 (n)

LOAD_CONST               1 (1)

INPLACE_ADD

STORE_GLOBAL             0 (n)

 import threading

 def addNum():

     global num

     #获得锁

     lock.acquire()

     num += 1

     #释放锁

     lock.release()

 def main():

     threads = []

     for i in range(100):

         t = threading.Thread(target=addNum)

         threads.append(t)

     for i in range(100):

         threads[i].start()

     for i in range(100):

         threads[i].join()

     print('num: ', num)

 num = 0

 lock = threading.Lock()

 if __name__ == '__main__':

     main()

 import threading

 import time

 def addNum():

     global num

     #获得锁

     semap.acquire()

     num += 1

     print('current num:', num)

     time.sleep(2)

     #释放锁

     semap.release()

 def main():

     threads = []

     for i in range(40):

         t = threading.Thread(target=addNum)

         threads.append(t)

     for i in range(40):

         threads[i].start()

     for i in range(40):

         threads[i].join()

     print('final num: ', num)

 num = 0

 semap = threading.BoundedSemaphore(4)

 if __name__ == '__main__':

     main()

 import threading

 import time

 def addNum():

     global num

     num += 1

     print('current num:', num)

     time.sleep(2)

 def main():

     threads = []

     for i in range(40):

         #定时器，设置为3s

         t = threading.Timer(3, addNum)

         threads.append(t)

     for i in range(40):

         #存在定时器，3s以后再开始执行

         threads[i].start()

     for i in range(40):

         threads[i].join()

     print('final num: ', num)

 num = 0

 if __name__ == '__main__':

     main()

 import threading

 import time

 def producer():

     print('厨师：等人买包子')

     event.wait()

     event.clear()

     print('厨师：有人来买包子了，开始做包子')

     time.sleep(3)

     print('厨师：你的包子做好了')

     event.set()

 def consumer():

     print('客户：老板，买包子')

     event.set()

     time.sleep(1)

     print('客户：老板，快点')

     event.wait()

     print('客户：谢谢老板，真好吃')

 event = threading.Event()

 p = threading.Thread(target=producer)

 c = threading.Thread(target=consumer)

 p.start()

 c.start()

厨师：等人买包子

客户：老板，买包子

厨师：有人来买包子了，开始做包子

客户：老板，快点

厨师：你的包子做好了

客户：谢谢老板，真好吃

 import threading

 import time

 def producer():

     print('厨师：等人买包子')

     event.wait()

     event.clear()

     print('厨师：有人来买包子了，开始做包子')

     time.sleep(5)

     print('厨师：你的包子做好了')

     event.set()

 def consumer():

     print('客户：老板，买包子')

     event.set()

     time.sleep(1)

     while not event.isSet():

         print('客户：老板还没好啊！饿死了')

         print('客户：我先干点别的吧，睡1秒')

         time.sleep(1)

     print('客户：谢谢老板，真好吃')

 event = threading.Event()

 p = threading.Thread(target=producer)

 c = threading.Thread(target=consumer)

 p.start()

 c.start()

厨师：等人买包子

客户：老板，买包子

厨师：有人来买包子了，开始做包子

客户：老板还没好啊！饿死了

客户：我先干点别的吧，睡1秒

客户：老板还没好啊！饿死了

客户：我先干点别的吧，睡1秒

客户：老板还没好啊！饿死了

客户：我先干点别的吧，睡1秒

客户：老板还没好啊！饿死了

客户：我先干点别的吧，睡1秒

厨师：你的包子做好了

客户：谢谢老板，真好吃

>>>

>>> from queue import Queue

>>> q = Queue(3)

>>> q.put('first_in')

>>> q.put('second_in')

>>> q.put('third_in')

>>>

>>> q.get()

'first_in'

>>> q.get()

'second_in'

>>> q.get()

'third_in'

>>>

>>> from queue import LifoQueue

>>> q_L = LifoQueue(3)

>>> q_L.put('first_in')

>>> q_L.put('second_in')

>>> q_L.put('third_in'))

>>> q_L.put('third_in')

>>>

>>>

>>> q_L.get()

'third_in'

>>> q_L.get()

'second_in'

>>> q_L.get()

'first_in'

>>>

>>> from queue import PriorityQueue

>>> q_P = PriorityQueue(3)

>>> q_P.put((6,'first_in'))

>>> q_P.put((1,'second_in'))

>>> q_P.put((10,'third_in'))

>>>

>>> q_P.get()

(1, 'second_in')

>>> q_P.get()

(6, 'first_in')

>>> q_P.get()

(10, 'third_in')

>>>

 from threading import Thread, RLock

 from queue import Queue

 import time

 q = Queue(10)

 count = 0

 l = RLock()

 #创建生产者

 class Producer(Thread):

     def __init__(self, name, que):

         super(Producer, self).__init__()

         self.__name = name

         self.__que = que

     def run(self):

         while True:

             global count

             l.acquire()

             count += 1

             l.release()

             self.__que.put(count)

             print('%s produce baozi %s' % (self.__name, count))

             time.sleep(0.5)

             self.__que.join()

 #创建消费者

 class Consumer(Thread):

     def __init__(self, name, que):

         super(Consumer, self).__init__()

         self.__name = name

         self.__que = que

     def run(self):

         while True:

             data = self.__que.get()

             print('%s eat baozi %s' % (self.__name, data))

             time.sleep(1)

             self.__que.task_done()

 def main():

     #创建1个生产者，3个消费者

     p1 = Producer('winter', q)

     c1 = Consumer('elly', q)

     c2 = Consumer('jack', q)

     c3 = Consumer('frank', q)

     p1.start()

     c1.start()

     c2.start()

     c3.start()

 if __name__ == '__main__':

     main()