python多线程与多进程及其区别

个人一直觉得对学习任何知识而言，概念是相当重要的。掌握了概念和原理，细节可以留给实践去推敲。掌握的关键在于理解，通过具体的实例和实际操作来感性的体会概念和原理可以起到很好的效果。本文通过一些具体的例子简单介绍一下python的多线程和多进程，后续会写一些进程通信和线程通信的一些文章。

python多线程

python中提供两个标准库thread和threading用于对线程的支持，python3中已放弃对前者的支持，后者是一种更高层次封装的线程库，接下来均以后者为例。

创建线程

python中有两种方式实现线程：

1. 实例化一个threading.thread的对象，并传入一个初始化函数对象（initial function )作为线程执行的入口；
2. 继承threading.thread，并重写run函数；

• 方式1：创建threading.thread对象

import threading
import time

def tstart(arg):
    time.sleep(0.5)
    print("%s running...." % arg)

if __name__ == '__main__':
    t1 = threading.thread(target=tstart, args=('this is thread 1',))
    t2 = threading.thread(target=tstart, args=('this is thread 2',))
    t1.start()
    t2.start()
    print("this is main function")

结果：

this is main function
this is thread 2 running....
this is thread 1 running....

• 方式2：继承threading.thread，并重写run

import threading
import time

class customthread(threading.thread):
    def __init__(self, thread_name):
        # step 1: call base __init__ function
        super(customthread, self).__init__(name=thread_name)
        self._tname = thread_name

    def run(self):
        # step 2: overide run function
        time.sleep(0.5)
        print("this is %s running...." % self._tname)

if __name__ == "__main__":
    t1 = customthread("thread 1")
    t2 = customthread("thread 2")
    t1.start()
    t2.start()
    print("this is main function")

 执行结果同方式1.

threading.thread

上面两种方法本质上都是直接或者间接使用threading.thread类

threading.thread(group=none, target=none, name=none, args=(), kwargs={})

关联上面两种创建线程的方式：

import threading
import time

class customthread(threading.thread):
    def __init__(self, thread_name, target = none):
        # step 1: call base __init__ function
        super(customthread, self).__init__(name=thread_name, target=target, args = (thread_name,))
        self._tname = thread_name

    def run(self):
        # step 2: overide run function
        # time.sleep(0.5)
        # print("this is %s running....@run" % self._tname)
        super(customthread, self).run()

def target(arg):
    time.sleep(0.5)
    print("this is %s running....@target" % arg)

if __name__ == "__main__":
    t1 = customthread("thread 1", target)
    t2 = customthread("thread 2", target)
    t1.start()
    t2.start()
    print("this is main function")

结果：

this is main function
this is thread 1 running....@target
this is thread 2 running....@target

上面这段代码说明：

1. 两种方式创建线程，指定的参数最终都会传给threading.thread类；
2. 传给线程的目标函数是在基类thread的run函数体中被调用的，如果run没有被重写的话。

threading模块的一些属性和方法可以参照官网，这里重点介绍一下threading.thread对象的方法

下面是threading.thread提供的线程对象方法和属性：

• start()：创建线程后通过start启动线程，等待cpu调度，为run函数执行做准备；
• run()：线程开始执行的入口函数，函数体中会调用用户编写的target函数，或者执行被重载的run函数；
• join([timeout])：阻塞挂起调用该函数的线程，直到被调用线程执行完成或超时。通常会在主线程中调用该方法，等待其他线程执行完成。
• name、getname()&setname()：线程名称相关的操作；
• ident：整数类型的线程标识符，线程开始执行前（调用start之前）为none；
• isalive()、is_alive()：start函数执行之后到run函数执行完之前都为true；
• daemon、isdaemon()&setdaemon()：守护线程相关；

这些是我们创建线程之后通过线程对象对线程进行管理和获取线程信息的方法。

 多线程执行

 在主线程中创建若线程之后，他们之间没有任何协作和同步，除主线程之外每个线程都是从run开始被执行，直到执行完毕。

join

我们可以通过join方法让主线程阻塞，等待其创建的线程执行完成。

import threading
import time

def tstart(arg):
    print("%s running....at: %s" % (arg,time.time()))
    time.sleep(1)
    print("%s is finished! at: %s" % (arg,time.time()))

if __name__ == '__main__':
    t1 = threading.thread(target=tstart, args=('this is thread 1',))
    t1.start()
    t1.join()   # 当前线程阻塞，等待t1线程执行完成
    print("this is main function at：%s" % time.time())

结果：

this is thread 1 running....at: 1564906617.43
this is thread 1 is finished! at: 1564906618.43
this is main function at：1564906618.43

如果不加任何限制，当主线程执行完毕之后，当前程序并不会结束，必须等到所有线程都结束之后才能结束当前进程。

将上面程序中的t1.join()去掉，执行结果如下：

this is thread 1 running....at: 1564906769.52
this is main function at：1564906769.52
this is thread 1 is finished! at: 1564906770.52

可以通过将创建的线程指定为守护线程（daemon），这样主线程执行完毕之后会立即结束未执行完的线程，然后结束程序。

deamon守护线程

import threading
import time

def tstart(arg):
    print("%s running....at: %s" % (arg,time.time()))
    time.sleep(1)
    print("%s is finished! at: %s" % (arg,time.time()))

if __name__ == '__main__':
    t1 = threading.thread(target=tstart, args=('this is thread 1',))
    t1.setdaemon(true)
    t1.start()
    # t1.join()   # 当前线程阻塞，等待t1线程执行完成
    print("this is main function at：%s" % time.time())

结果：

this is thread 1 running....at: 1564906847.85
this is main function at：1564906847.85

python多进程

相比较于threading模块用于创建python多线程，python提供multiprocessing用于创建多进程。先看一下创建进程的两种方式。

the multiprocessing package mostly replicates the api of the threading module.　　—— python doc

创建进程

创建进程的方式和创建线程的方式类似：

1. 实例化一个multiprocessing.process的对象，并传入一个初始化函数对象（initial function )作为新建进程执行入口；
2. 继承multiprocessing.process，并重写run函数；

• 方式1：

from multiprocessing import process  
import os, time

def pstart(name):
    # time.sleep(0.1)
    print("process name: %s, pid: %s "%(name, os.getpid()))

if __name__ == "__main__": 
    subproc = process(target=pstart, args=('subprocess',))  
    subproc.start()  
    subproc.join()
    print("subprocess pid: %s"%subproc.pid)
    print("current process pid: %s" % os.getpid())

结果：

process name: subprocess, pid: 4888 
subprocess pid: 4888
current process pid: 9912

• 方式2：

from multiprocessing import process  
import os, time

class customprocess(process):
    def __init__(self, p_name, target=none):
        # step 1: call base __init__ function()
        super(customprocess, self).__init__(name=p_name, target=target, args=(p_name,))

    def run(self):
        # step 2:
        # time.sleep(0.1)
        print("custom process name: %s, pid: %s "%(self.name, os.getpid()))

if __name__ == '__main__':
    p1 = customprocess("process_1")
    p1.start()
    p1.join()
    print("subprocess pid: %s"%p1.pid)
    print("current process pid: %s" % os.getpid())

这里可以思考一下，如果像多线程一样，存在一个全局的变量share_data，不同进程同时访问share_data会有问题吗？

由于每一个进程拥有独立的内存地址空间且互相隔离，因此不同进程看到的share_data是不同的、分别位于不同的地址空间，同时访问不会有问题。这里需要注意一下。

subprocess模块

既然说道了多进程，那就顺便提一下另一种创建进程的方式。

python提供了sunprocess模块可以在程序执行过程中，调用外部的程序。

如我们可以在python程序中打开记事本，打开cmd，或者在某个时间点关机:

>>> import subprocess
>>> subprocess.popen(['cmd'])
<subprocess.popen object at 0x0339f550>
>>> subprocess.popen(['notepad'])
<subprocess.popen object at 0x03262b70>
>>> subprocess.popen(['shutdown', '-p'])

或者使用ping测试一下网络连通性：

>>> res = subprocess.popen(['ping', 'www.cnblogs.com'], stdout=subprocess.pipe).communicate()[0]
>>> print res
正在 ping www.cnblogs.com [101.37.113.127] 具有 32 字节的数据:

来自 101.37.113.127 的回复: 字节=32 时间=1ms ttl=91
来自 101.37.113.127 的回复: 字节=32 时间=1ms ttl=91
来自 101.37.113.127 的回复: 字节=32 时间=1ms ttl=91
来自 101.37.113.127 的回复: 字节=32 时间=1ms ttl=91

101.37.113.127 的 ping 统计信息:
数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
最短 = 1ms，最长 = 1ms，平均 = 1ms

python多线程与多进程比较

先来看两个例子：

开启两个python线程分别做一亿次加一操作，和单独使用一个线程做一亿次加一操作：

def tstart(arg):
    var = 0
    for i in xrange(100000000):
        var += 1

if __name__ == '__main__':
    t1 = threading.thread(target=tstart, args=('this is thread 1',))
    t2 = threading.thread(target=tstart, args=('this is thread 2',))
    start_time = time.time()
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("two thread cost time: %s" % (time.time() - start_time))
    start_time = time.time()
    tstart("this is thread 0")
    print("main thread cost time: %s" % (time.time() - start_time))

结果：

two thread cost time: 20.6570000648
main thread cost time: 2.52800011635

上面的例子如果只开启t1和t2两个线程中的一个，那么运行时间和主线程基本一致。这个后面会解释原因。

使用两个进程进行上面的操作：

def pstart(arg):
    var = 0
    for i in xrange(100000000):
        var += 1

if __name__ == '__main__':
    p1 = process(target = pstart, args = ("1", ))
    p2 = process(target = pstart, args = ("2", ))
    start_time = time.time()
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print("two process cost time: %s" % (time.time() - start_time))
    start_time = time.time()
    pstart("0")
    print("current process cost time: %s" % (time.time() - start_time))

结果：

two process cost time: 2.91599988937
current process cost time: 2.52400016785

对比分析

双进程并行执行和单进程执行相同的运算代码，耗时基本相同，双进程耗时会稍微多一些，可能的原因是进程创建和销毁会进行系统调用，造成额外的时间开销。

但是对于python线程，双线程并行执行耗时比单线程要高的多，效率相差近10倍。如果将两个并行线程改成串行执行，即：

    t1.start()
    t1.join()
    t2.start()
    t2.join()
    #two thread cost time: 5.12199997902
    #main thread cost time: 2.54200005531

可以看到三个线程串行执行，每一个执行的时间基本相同。

本质原因双线程是并发执行的，而不是真正的并行执行。原因就在于gil锁。

gil锁

提起python多线程就不得不提一下gil(global interpreter lock 全局解释器锁)，这是目前占统治地位的python解释器cpython中为了保证数据安全所实现的一种锁。不管进程中有多少线程，只有拿到了gil锁的线程才可以在cpu上运行，即时是多核处理器。对一个进程而言，不管有多少线程，任一时刻，只会有一个线程在执行。对于cpu密集型的线程，其效率不仅仅不高，反而有可能比较低。python多线程比较适用于io密集型的程序。对于的确需要并行运行的程序，可以考虑多进程。

多线程对锁的争夺，cpu对线程的调度，线程之间的切换等均会有时间开销。

线程与进程区别

下面简单的比较一下线程与进程

• 进程是资源分配的基本单位，线程是cpu执行和调度的基本单位；
• 通信/同步方式：
• 进程：
  • 通信方式：管道，fifo，消息队列，信号，共享内存，socket，stream流；
  • 同步方式：pv信号量，管程
• 线程：
  • 同步方式：互斥锁，递归锁，条件变量，信号量
  • 通信方式：位于同一进程的线程共享进程资源，因此线程间没有类似于进程间用于数据传递的通信方式，线程间的通信主要是用于线程同步。
• cpu上真正执行的是线程，线程比进程轻量，其切换和调度代价比进程要小；
• 线程间对于共享的进程数据需要考虑线程安全问题，由于进程之间是隔离的，拥有独立的内存空间资源，相对比较安全，只能通过上面列出的ipc(inter-process communication)进行数据传输；
• 系统有一个个进程组成，每个进程包含代码段、数据段、堆空间和栈空间，以及操作系统共享部分 ，有等待，就绪和运行三种状态；
• 一个进程可以包含多个线程，线程之间共享进程的资源（文件描述符、全局变量、堆空间等），寄存器变量和栈空间等是线程私有的；
• 操作系统中一个进程挂掉不会影响其他进程，如果一个进程中的某个线程挂掉而且os对线程的支持是多对一模型，那么会导致当前进程挂掉；
• 如果cpu和系统支持多线程与多进程，多个进程并行执行的同时，每个进程中的线程也可以并行执行，这样才能最大限度的榨取硬件的性能；

线程和进程的上下文切换

进程切换过程切换牵涉到非常多的东西，寄存器内容保存到任务状态段tss，切换页表，堆栈等。简单来说可以分为下面两步：

1. 页全局目录切换，使cpu到新进程的线性地址空间寻址；
2. 切换内核态堆栈和硬件上下文，硬件上下文包含cpu寄存器的内容，存放在tss中；

线程运行于进程地址空间，切换过程不涉及到空间的变换，只牵涉到第二步；

使用多线程还是多进程？

cpu密集型：程序需要占用cpu进行大量的运算和数据处理；

i/o密集型：程序中需要频繁的进行i/o操作；例如网络中socket数据传输和读取等；

由于python多线程并不是并行执行，因此较适合与i/o密集型程序，多进程并行执行适用于cpu密集型程序；