线程与进程
    在 Python 中我们要同时执行多个任务，有两种解决方案：1(**是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。2(是启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务。当然还有第三种方法，就是启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更复杂，实际很少采用**。
    总结一下就是，多任务的实现有3种方式：

    • 多进程模式；
    • 多线程模式；
    • 多进程+多线程模式。

    同时执行多个任务通常各个任务之间并不是没有关联的，而是需要相互通信和协调，有时，任务 1 必须暂停等待任务 2 完成后才能继续执行，有时，任务 3 和任务 4 又不能同时执行，所以，多进程和多线程的程序的复杂度要远远高于我们前面写的单进程单线程的程序。
    其实创建线程之后，线程并不是始终保持一个状态的，其状态大概如下：

    • New 创建
    • Runnable 就绪。等待调度
    • Running 运行
    • Blocked 阻塞。阻塞可能在 Wait Locked Sleeping
    • Dead 消亡

    线程有着不同的状态，也有不同的类型。大致可分为：

    • 主线程
    • 子线程
    • 守护线程（后台线程）
    • 前台线程

    Python 提供两个模块进行多线程的操作，分别是thread 和 thread
    前者是比较低级的模块，用于更底层的操作，一般应用级别的开发不常用。
    因此，我们使用 threading来举个例子

    1. import time
    2. import threading
    3. class MyThread(threading.Thread):
    4.     def run(self):
    5.         for i in range(5):
    6.             print('thread {}, @number: {}'.format(self.name, i))
    7.             time.sleep(1)
    8. def main():
    9.     print("Start main threading")
    10.     # 创建三个线程
    11.     threads = [MyThread() for i in range(3)]
    12.     # 启动三个线程
    13.     for t in threads:
    14.         t.start()
    15.     print("End Main threading")
    16. if __name__ == '__main__':
    17.     main()

    线程合并(join方法)
    上面的示例打印出来的结果来看，主线程结束后，子线程还在运行。那么我们需要主线程要等待子线程运行完后，再退出，要怎么办呢？
    这时候，就需要用到join方法了。
    在上面的例子，新增一段代码，具体如下：

    1. # 一次让新创建的线程执行 join
    2.     for t in threads:
    3.         t.join()
    4.     print("End Main threading")
    5. if __name__ == '__main__':
    6.     main()

    在加了这段代码后，输出结果会大大清晰很多
    线程同步与互斥锁
    使用线程加载获取数据，通常都会造成数据不同步的情况。当然，这时候我们可以给资源进行加锁，也就是访问资源的线程需要获得锁才能访问。
    其中 threading 模块给我们提供了一个 Lock 功能

    1. lock = threading.Lock()

    在线程中获取锁

    1. lock.acquire()

    使用完成后，我们肯定需要释放锁

    1. lock.release()

    当然为了支持在同一线程中多次请求同一资源，Python 提供了可重入锁（RLock）。RLock 内部维护着一个 Lock 和一个 counter 变量，counter 记录了 acquire 的次数，从而使得资源可以被多次 require。直到一个线程所有的 acquire 都被 release，其他的线程才能获得资源。
    Condition 条件变量
    实用锁可以达到线程同步，但是在更复杂的环境，需要针对锁进行一些条件判断。
    Python 提供了 Condition 对象。
    使用 Condition 对象可以在某些事件触发或者达到特定的条件后才处理数据，Condition 除了具有 Lock 对象的 acquire 方法和 release 方法外，还提供了 wait 和 notify 方法。
    线程首先 acquire 一个条件变量锁。如果条件不足，则该线程 wait，如果满足就执行线程，甚至可以 notify 其他线程。其他处于 wait 状态的线程接到通知后会重新判断条件。
    其中条件变量可以看成不同的线程先后 acquire 获得锁，如果不满足条件，可以理解为被扔到一个（ Lock 或 RLock ）的 waiting 池。直到其他线程 notify 之后再重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

    1. import threading, time
    2. class Consumer(threading.Thread):
    3.     def __init__(self, cond, name):
    4.         # 初始化
    5.         super(Consumer, self).__init__()
    6.         self.cond = cond
    7.         self.name = name
    8.     def run(self):
    9.         # 确保先运行Seeker中的方法
    10.         time.sleep(1)
    11.         self.cond.acquire()
    12.         print(self.name + ': 我这两件商品一起买，可以便宜点吗')
    13.         self.cond.notify()
    14.         self.cond.wait()
    15.         print(self.name + ': 我已经提交订单了，你修改下价格')
    16.         self.cond.notify()
    17.         self.cond.wait()
    18.         print(self.name + ': 收到，我支付成功了')
    19.         self.cond.notify()
    20.         self.cond.release()
    21.         print(self.name + ': 等待收货')
    22. class Producer(threading.Thread):
    23.     def __init__(self, cond, name):
    24.         super(Producer, self).__init__()
    25.         self.cond = cond
    26.         self.name = name
    27.     def run(self):
    28.         self.cond.acquire()
    29.         # 释放对琐的占用，同时线程挂起在这里，直到被 notify 并重新占有琐。
    30.         self.cond.wait()
    31.         print(self.name + ': 可以的，你提交订单吧')
    32.         self.cond.notify()
    33.         self.cond.wait()
    34.         print(self.name + ': 好了，已经修改了')
    35.         self.cond.notify()
    36.         self.cond.wait()
    37.         print(self.name + ': 嗯，收款成功，马上给你发货')
    38.         self.cond.release()
    39.         print(self.name + ': 发货商品')
    40. cond = threading.Condition()
    41. consumer = Consumer(cond, '买家（两点水）')
    42. producer = Producer(cond, '卖家（三点水）')
    43. consumer.start()
    44. producer.start()

    输出的结果如下：

    1. 买家（两点水）: 我这两件商品一起买，可以便宜点吗
    2. 卖家（三点水）: 可以的，你提交订单吧
    3. 买家（两点水）: 我已经提交订单了，你修改下价格
    4. 卖家（三点水）: 好了，已经修改了
    5. 买家（两点水）: 收到，我支付成功了
    6. 买家（两点水）: 等待收货
    7. 卖家（三点水）: 嗯，收款成功，马上给你发货
    8. 卖家（三点水）: 发货商品

    线程间通信
    如果程序中有多个线程，这些线程避免不了需要相互通信的。从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的Queue 对象，这些线程通过使用put() 和 get() 操作来向队列中添加或者删除元素。

    1. from queue import Queue
    2. from threading import Thread
    3. isRead = True
    4. def write(q):
    5.     # 写数据进程
    6.     for value in ['两点水', '三点水', '四点水']:
    7.         print('写进 Queue 的值为：{0}'.format(value))
    8.         q.put(value)
    9. def read(q):
    10.     # 读取数据进程
    11.     while isRead:
    12.         value = q.get(True)
    13.         print('从 Queue 读取的值为：{0}'.format(value))
    14. if __name__ == '__main__':
    15.     q = Queue()
    16.     t1 = Thread(target=write, args=(q,))
    17.     t2 = Thread(target=read, args=(q,))
    18.     t1.start()
    19.     t2.start()

    输出的结果如下：

    1. 写进 Queue 的值为：两点水
    2. 写进 Queue 的值为：三点水
    3. 从 Queue 读取的值为：两点水
    4. 写进 Queue 的值为：四点水
    5. 从 Queue 读取的值为：三点水
    6. 从 Queue 读取的值为：四点水

    Python 还提供了 Event 对象用于线程间通信，它是由线程设置的信号标志，如果信号标志位真，则其他线程等待直到信号接触。
    Event 对象实现了简单的线程通信机制，它提供了设置信号，清楚信号，等待等用于实现线程间的通信。

    • 设置信号

    使用 Event 的 set() 方法可以设置 Event 对象内部的信号标志为真。Event 对象提供了 isSet() 方法来判断其内部信号标志的状态。当使用 event 对象的 set() 方法后，isSet() 方法返回真

    • 清除信号

    使用 Event 对象的clear() 方法可以清除 Event 对象内部的信号标志，即将其设为假，当使用 Event 的 clear 方法后，isSet() 方法返回假

    • 等待

    Event 对象 wait 的方法只有在内部信号为真的时候才会很快的执行并完成返回。当 Event 对象的内部信号标志位假时，则 wait 方法一直等待到其为真时才返回。