多线程与多进程

基本概念

进程和线程

我们都知道现代的操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。

而多任务意思就是操作系统可以同时运行多个任务。就像我们的电脑同时开好多应用，这就是多任务。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

单核cpu执行多任务其实也是顺序执行而不是同步的。操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核cpu上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

对于操作系统来说，一个任务就是一个进程（Process），有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。

由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

所以我们要同时执行多个任务可以通过多进程或者多线程或者他俩的组合模式，至于如何选择会在下边说到。

线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。

多进程

Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。
子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

由于Windows没有fork调用，而Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

multiprocessing模块提供了一个Process类来代表一个进程对象.创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

多线程

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
程序的运行速度可能加快
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。

线程在执行过程中与进程还是有区别的。每个独立的进程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

线程可以被抢占（中断）。
在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） – 这就是线程的退让。

线程的生命周期

就绪：线程能够运行，但是在等待被调用，可能线程刚刚创建启动，或者刚刚从阻塞中恢复，或者被其他线程抢占。

运行：线程正在运行。

阻塞：线程等待外部时间发生而且无法运行，如I/O操作。

终止:线程完成，或推迟，或被取消。

解决并发模型

以下以火车站进站模型为例
1.队列，缓冲区
例子：火车站的乘客排队进站，排成的队就是一个缓冲区。军人，老幼病残优先，所以也有优先队列。
(queue模块的类queue，redis等)
2.争抢模式
谁抢到算谁的。同一时间只能进去一人，一个人进去，其余人不能进，等他进去后才能再进。
(锁机制：文件锁和线程锁)
3.预处理模式
在高峰时期多开几个通道，维持秩序。
(一种提前加载用户需求的数据思路，预处理思想，缓存常用)
4.并行模式
进站分为不同的进站口，每个进站口分为不同的队列，加速进站。
(可以通过购买服务器，多开进程，线程实现并行处理解决并发问题，水平扩展，分布式思想)
5.提速
多通道无法满足现阶段需求，进站不是问题，问题是如何传运如此多的人，把绿皮火车换为高铁，提高自身硬件条件。
(通过更新cpu,内存，硬盘等资源)
6.消息中间件
在进站前增加安检，在安检时就进行排队
（计算机中常见的消息中间件RabbitMQ,ActiveMQ(Apache),PocketMQ(Ali),Kafka(Apache)等）

线程属性

线程模块

Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。
threading 模块提供的其他方法：

threading.currentThread(): 返回当前的线程变量。

threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

run(): 用以表示线程活动的方法。

start():启动线程活动。

join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。

isAlive(): 返回线程是否活动的。

getName(): 返回线程名。

setName(): 设置线程名。

使用Threading模块创建线程

下边是一个红路灯车辆行驶的例子：

import time
import threading
llight = {}
def linght(sconds):
    count = 5
    llight[threading.current_thread().name]="ret"
    while True:
        name = threading.current_thread().name
        print("{} is {} now!,senconds is {}".format(name,llight[threading.current_thread().name],count))
        count -= 1
        if count == 0 and llight[threading.current_thread().name] == "ret":
            llight[threading.current_thread().name] = "blue"
            count = 5
        if count == 0 and llight[threading.current_thread().name] == "blue":
            llight[threading.current_thread().name] = "ret"
            count = 5
        time.sleep(sconds)

def car(s):
    for k,v in llight.items():
        if v == "ret":
            count = 0
            while True:
                time.sleep(0.5)
                count += 0.5
                if llight[k] != "ret":
                    print("ret to blue,car pass")
                    break
                if count > s:
                    print("ret ret go go go!")
                    break
        else:
            print("blue light pass".format(k))



lt = threading.Thread(target=linght,args=(2,),name="light1").start()
lt1 = threading.Thread(target=linght,args=(4,),name="light2").start()
ct = threading.Thread(target=car,args=(6,)).start()

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

线程同步Event

Event事件，是线程间通信机制中最简单的实现，使用一个内部标记flag，通过flag的true或false的变化进行操作。

event = threading.Event()

print(“ready”)

print(event.wait(4))#默认false，执行wait时长为4s，函数返回值

print(“done”)

线程同步Lock,Rlock

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。

那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。

经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。

可重复锁rlock，在一个线程中，可以锁多次，锁多次时，就要对于的解锁多次，否则其他阻塞锁中，无法执行任务

线程不同:condition

构造方法Condition(lock=None),可以传入一个lock或Rlock对象，默认是Rlock

Conddition用于生产者、消费者模型，为了解决生产者和消费者速度不匹配的问题。
使用方式：
使用Condition,必须先acquire,用完了要release,因为内部使用了锁，默认使用了Rlock锁，最好使用方式是with上下文。
消费者wait，等待通知。
生产者生产好消息，对消费者发通知，可以使用notify或者notify_all方法
通知案例：

cond = threading.Condition()
env = threading.Event()
data = 0
def produce(total):
    for _ in range(total):
        global data
        data = random.randint(0,100)
        with cond:
            print(data)
            cond.notify_notify(n=2)
        env.wait(1)
    env.set()
def consume():
    global  data
    while not env.is_set():
        with cond:
            cond.wait()  #阻塞等通知
            print("received {}".format(data))
            data = None
        env.wait(0.5)
p = threading.Thread(target=produce,args=(10,),name="producer")
for con in range(5):
    con = threading.Thread(target=consume,name=“consumer”)         #5个消费者，等待处理，现在最多通知5个，一对多广播
    con.start()
p.start()

线程优先级队列（ Queue）

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

实例 ：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import Queue
import threading
import time
 
exitFlag = 0
 
class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print "Starting " + self.name
        process_data(self.name, self.q)
        print "Exiting " + self.name
 
def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
        else:
            queueLock.release()
        time.sleep(1)
 
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1
 
# 创建新线程
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1
 
# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()
 
# 等待队列清空
while not workQueue.empty():
    pass
 
# 通知线程是时候退出
exitFlag = 1
 
# 等待所有线程完成
for t in threads:
    t.join()
print "Exiting Main Thread"

结果：

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

进程与线程的区别

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的物理地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些；但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

1. 一个程序至少有一个进程,一个进程至少有一个线程.
2. 线程的划分尺度小于进程，使得多线程程序的并发性高。
3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4. 线程在执行过程中与进程还是有区别的。每个独立的进程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。
6. 线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP(多核处理机)机器上运行，而进程则可以跨机器迁移。
7. 进程的执行过程是线状的，尽管中间会发生中断或暂停，但该进程所拥有的资源只为该线状执行过程服务。一旦发生进程上下文切换，这些资源都是要被保护起来的。这是进程宏观上的执行过程。
8. 进程又可有单线程进程与多线程进程两种；我们知道，进程有 一个进程控制块 PCB 、程序段 和相关数据块 三部分，单线程进程的执行过程在宏观上是线性的，微观上也只有单一的执行过程；而多线程进程在宏观上的执行过程同样为线性的，但微观上却可以有多个执行操作（线程），如不同代码片段以及相关的数据结构集。

线程也有自己的线程控制表 TCB，所保存的线程状态信息则要比 PCB 表少得多，主要是相关指针用堆栈（系统栈和用户栈）、寄存器中的状态数据，线程的改变只代表了 CPU 执行过程的改变，而没有发生进程所拥有的资源变化。

9. 进程拥有一个完整的虚拟地址空间，不依赖于线程而独立存在；反之，线程是进程的一部分，没有自己的地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

线程可以有效地提高系统的执行效率，但并不是在所有计算机系统中都是适用的，如某些很少做进程调度和切换的实时系统。使用线程的好处是有多个任务需要处理机处理时，减少处理机的切换时间；而且，线程的创建和结束所需要的系统开销也比进程的创建和结束要小得多。最适合使用线程的系统是多处理机系统和网络系统或分布式系统。

10. 进程只有 3 个基本状态：就绪，执行，阻塞；线程存在 5 种基本操作来切换线程的状态：派生，阻塞，激活，调度，结束。font

多线程适合IO密集型任务,多进程适合计算密集型任务