python多进程和多线程《二》

原文：一文看懂Python多进程与多线程编程(工作学习面试必读) - 知乎 (zhihu.com)

Python的多线程编程与threading模块

python 3中的多进程编程主要依靠threading模块。创建新线程与创建新进程的方法非常类似。threading.Thread方法可以接收两个参数, 第一个是target，一般指向函数名，第二个时args，需要向函数传递的参数。对于创建的新线程，调用start()方法即可让其开始。我们还可以使用current_thread().name打印出当前线程的名字。 下例中我们使用多线程技术重构之前的计算代码。

import threading
import time

def long_time_task(i):
print('当前子线程: {} - 任务{}'.format(threading.current_thread().name, i))
time.sleep(2)
print("结果: {}".format(8 ** 20))

if name=='main':
start = time.time()
print('这是主线程：{}'.format(threading.current_thread().name))
t1 = threading.Thread(target=long_time_task, args=(1,))
t2 = threading.Thread(target=long_time_task, args=(2,))
t1.start()
t2.start()

end = time.time()
print("总共用时{}秒".format((end - start)))

下面是输出结果。为什么总耗时居然是0秒? 我们可以明显看到主线程和子线程其实是独立运行的，主线程根本没有等子线程完成，而是自己结束后就打印了消耗时间。主线程结束后，子线程仍在独立运行，这显然不是我们想要的。

这是主线程：MainThread
当前子线程: Thread-1 - 任务1
当前子线程: Thread-2 - 任务2
总共用时0.0017192363739013672秒
结果: 1152921504606846976
结果: 1152921504606846976

如果要实现主线程和子线程的同步，我们必需使用join方法（代码如下所示)。

import threading
import time

def long_time_task(i):
print('当前子线程: {} 任务{}'.format(threading.current_thread().name, i))
time.sleep(2)
print("结果: {}".format(8 ** 20))

if name=='main':
start = time.time()
print('这是主线程：{}'.format(threading.current_thread().name))
thread_list = []
for i in range(1, 3):
t = threading.Thread(target=long_time_task, args=(i, ))
thread_list.append(t)

for t in thread_list:
    t.start()

for t in thread_list:
    t.join()

end = time.time()
print("总共用时{}秒".format((end - start)))

修改代码后的输出如下所示。这时你可以看到主线程在等子线程完成后才答应出总消耗时间(2秒)，比正常顺序执行代码(4秒)还是节省了不少时间。

这是主线程：MainThread
当前子线程: Thread - 1 任务1
当前子线程: Thread - 2 任务2
结果: 1152921504606846976
结果: 1152921504606846976
总共用时2.0166890621185303秒

当我们设置多线程时，主线程会创建多个子线程，在python中，默认情况下主线程和子线程独立运行互不干涉。如果希望让主线程等待子线程实现线程的同步，我们需要使用join()方法。如果我们希望一个主线程结束时不再执行子线程，我们应该怎么办呢? 我们可以使用t.setDaemon(True)，代码如下所示。

import threading
import time

def long_time_task():
print('当子线程: {}'.format(threading.current_thread().name))
time.sleep(2)
print("结果: {}".format(8 ** 20))

if name=='main':
start = time.time()
print('这是主线程：{}'.format(threading.current_thread().name))
for i in range(5):
t = threading.Thread(target=long_time_task, args=())
t.setDaemon(True)
t.start()

end = time.time()
print("总共用时{}秒".format((end - start)))

通过继承Thread类重写run方法创建新进程

除了使用Thread()方法创建新的线程外，我们还可以通过继承Thread类重写run方法创建新的线程，这种方法更灵活。下例中我们自定义的类为MyThread, 随后我们通过该类的实例化创建了2个子线程。

-- encoding:utf-8 --

import threading
import time

def long_time_task(i):
time.sleep(2)
return 8**20

class MyThread(threading.Thread):
def init(self, func, args , name='', ):
threading.Thread.init(self)
self.func = func
self.args = args
self.name = name
self.result = None

def run(self):
    print('开始子进程{}'.format(self.name))
    self.result = self.func(self.args[0],)
    print("结果: {}".format(self.result))
    print('结束子进程{}'.format(self.name))

if name=='main':
start = time.time()
threads = []
for i in range(1, 3):
t = MyThread(long_time_task, (i,), str(i))
threads.append(t)

for t in threads:
    t.start()
for t in threads:
    t.join()

end = time.time()
print("总共用时{}秒".format((end - start)))

输出结果如下所示:

开始子进程1
开始子进程2
结果: 1152921504606846976
结果: 1152921504606846976
结束子进程1
结束子进程2
总共用时2.005445718765259秒

不同线程间的数据共享

一个进程所含的不同线程间共享内存，这就意味着任何一个变量都可以被任何一个线程修改，因此线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。如果不同线程间有共享的变量，其中一个方法就是在修改前给其上一把锁lock，确保一次只有一个线程能修改它。threading.lock()方法可以轻易实现对一个共享变量的锁定，修改完后release供其它线程使用。比如下例中账户余额balance是一个共享变量，使用lock可以使其不被改乱。

-- coding: utf-8 -

import threading

class Account:
def init(self):
self.balance = 0

def add(self, lock):
    # 获得锁
    lock.acquire()
    for i in range(0, 100000):
        self.balance += 1
    # 释放锁
    lock.release()

def delete(self, lock):
    # 获得锁
    lock.acquire()
    for i in range(0, 100000):
        self.balance -= 1
        # 释放锁
    lock.release()

if name == "main":
account = Account()
lock = threading.Lock()
# 创建线程
thread_add = threading.Thread(target=account.add, args=(lock,), name='Add')
thread_delete = threading.Thread(target=account.delete, args=(lock,), name='Delete')

# 启动线程

thread_add.start()
thread_delete.start()

# 等待线程结束

thread_add.join()
thread_delete.join()

print('The final balance is: {}'.format(account.balance))

另一种实现不同线程间数据共享的方法就是使用消息队列queue。不像列表，queue是线程安全的，可以放心使用，见下文。

使用queue队列通信-经典的生产者和消费者模型

下例中创建了两个线程，一个负责生成，一个负责消费，所生成的产品存放在queue里，实现了不同线程间沟通。

from queue import Queue
import random, threading, time

生产者类

class Producer(threading.Thread):
def init(self, name, queue):
threading.Thread.init(self, name=name)
self.queue = queue

def run(self):
    for i in range(1, 5):
        print("{} is producing {} to the queue!".format(self.getName(), i))
        self.queue.put(i)
        time.sleep(random.randrange(10) / 5)
    print("%s finished!" % self.getName())

消费者类

class Consumer(threading.Thread):
def init(self, name, queue):
threading.Thread.init(self, name=name)
self.queue = queue

def run(self):
    for i in range(1, 5):
        val = self.queue.get()
        print("{} is consuming {} in the queue.".format(self.getName(), val))
        time.sleep(random.randrange(10))
    print("%s finished!" % self.getName())

def main():
queue = Queue()
producer = Producer('Producer', queue)
consumer = Consumer('Consumer', queue)

producer.start()
consumer.start()

producer.join()
consumer.join()
print('All threads finished!')

if name == 'main':
main()

队列queue的put方法可以将一个对象obj放入队列中。如果队列已满，此方法将阻塞至队列有空间可用为止。queue的get方法一次返回队列中的一个成员。如果队列为空，此方法将阻塞至队列中有成员可用为止。queue同时还自带emtpy(), full()等方法来判断一个队列是否为空或已满，但是这些方法并不可靠，因为多线程和多进程，在返回结果和使用结果之间，队列中可能添加/删除了成员。

Python多进程和多线程哪个快?

由于GIL的存在，很多人认为Python多进程编程更快，针对多核CPU，理论上来说也是采用多进程更能有效利用资源。网上很多人已做过比较，我直接告诉你结论吧。

对CPU密集型代码(比如循环计算) - 多进程效率更高
对IO密集型代码(比如文件操作，网络爬虫) - 多线程效率更高。
为什么是这样呢？其实也不难理解。对于IO密集型操作，大部分消耗时间其实是等待时间，在等待时间中CPU是不需要工作的，那你在此期间提供双CPU资源也是利用不上的，相反对于CPU密集型代码，2个CPU干活肯定比一个CPU快很多。那么为什么多线程会对IO密集型代码有用呢？这时因为python碰到等待会释放GIL供新的线程使用，实现了线程间的切换。

小结

本文总结了多进程和多线程的概念和区别, 并详细介绍如何使用python的multiprocess和threading模块进行多线程和多进程编程。我们还简单介绍了不同进程和线程间的通信和数据共享。如果您能熟练掌握本文中的所有知识点，那么你已经足以应付大部分面试和工作需求了。如果喜欢本文，就加入微信收藏常来看看吧。