浅析Python多线程

学习Python多线程的资料很多,吐槽Python多线程的博客也不少。本文主要介绍Python多线程实际应用,且假设读者已经了解多线程的基本概念。如果读者对进程线程概念不甚了解,可参见知名博主 阮一峰 转译的一篇博客:《进程与线程的一个简单解释》

1 线程的基本操作

Python中多线程主要有两个模块,_thread和threading模块。前者更底层,后者更常用,能满足绝大部分编程需求,今天主要围绕threading模块展开介绍。启动一个线程需要用threading模块中的Thread。

线程的启动需要先创建Thread对象,然后调用该对象的start()方法,参见下例:

import time
import threading

def func(n):
    while n > 0:
        print("线程name:", threading.current_thread().name, "参数n:", n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=func, args=(5,))
t.start()
print("主线程:", threading.current_thread().name)
# 运行结果:
# 线程name: Thread-1 参数n: 5
# 主线程: MainThread
# 线程name: Thread-1 参数n: 4
# 线程name: Thread-1 参数n: 3
# 线程name: Thread-1 参数n: 2
# 线程name: Thread-1 参数n: 1

上例中,threading.current_thread().name 是获取当前线程的name属性。

Thread中,形参target传入函数名,args传入函数对应的参数,参数必须是可迭代对象,如果是元组且只有一个参数必须写成(参数,)的形式,逗号不能省略

一旦启动一个线程,该线程将由操作系统来全权管理,独立执行直到目标函数返回。一般情况下,线程的操作有以下几种:

t.is_alive()    # 查询线程对象的状态,返回布尔值
t.join()        # 将线程加入到当前线程,并等待其终止

t = Thread(target=countdown, args=(10,), daemon=True)  # 后台线程
t.start()  

查看线程状态示例:

import time
import threading

def func(n):
    while n > 0:
        print("线程name:", threading.current_thread().name, "参数n:", n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=func, args=(2,))
t.start()
print("主线程:", threading.current_thread().name)

if t.is_alive():
    print("活着的")
else:
    print("未存活")
print("主线程结束")

让主线程等待其他线程,就是主线程会在join()处一直等待所有线程都结束之后,再继续运行。参见下例:

import time
import threading

def func(n):
    while n > 0:
        print("线程name:", threading.current_thread().name, "参数n:", n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=func, args=(2,))
t.start()
t.join()
print("主线程:", threading.current_thread().name)
print("主线程结束")
# 运行结果:
# 线程name: Thread-1 参数n: 2
# 线程name: Thread-1 参数n: 1
# 主线程: MainThread
# 主线程结束

后台线程参见下例:

import time
import threading

def func(n):
    while n > 0:
        print("参数n:", n)
        n -= 1
        time.sleep(1)

t = threading.Thread(target=func, args=(10, ), daemon=True)
t.start()
time.sleep(3)
print("主线程结束")

# 参数n: 10
# 参数n: 9
# 参数n: 8
# 参数n: 7
# 主线程结束

后台线程无法等待,但主线程终止时后台线程自动销毁。 如果要对线程进行高级操作,如发送信号终止线程,都需要自己实现。下例通过轮询控制线程退出

import time
from threading import Thread

class StopThread:
    def __init__(self):
        self._flag = True

    def terminate(self):
        self._flag = False

    def run(self, n):
        while self._flag and n > 0:
            print('num>>:', n)
            n -= 1
            time.sleep(1)

obj = StopThread()
t = Thread(target=obj.run, args=(11,))
t.start()

time.sleep(5)    # 表示do something

obj.terminate()  # 终止线程
t.join()
print("主线程结束")

上例通过类中的_flag控制线程的终止,当主线程执行5秒之后,主动将_flag赋值为False终止线程。通过轮询终止线程存在一个问题,如果while self._flag and n > 0:这句后,某次循环一直阻塞在I/O操作上,根本不会进行下一次循环,自然就无法终止。这该怎么办呢?留一个思考题。

多线程还可以通过继承Thread实现,如下:

import time
from threading import Thread

class A(Thread):
    def __init__(self,):
        super().__init__()

    def run(self):
        print("run1..", )
        time.sleep(5)
        print("run2..")

obj = A()
obj.start()
print("主线程结束")

2 线程锁和一个怪象

当我们用多个线程同时修改同一份数据时,怎么保证最终结果是我们期许的呢?举个例子,当前有一个全局变量a=0,如果有10个线程同时对其加1,这就出现了线程间的竞争,到底应该听谁的呢?这时候,应该用线程锁来解决。也就是当某一个线程A对该数据操作时,对该数据加锁,其他线程只能等着,等待A操作完之后释放了该锁,其他线程才能操作该数据,一旦某个线程获得操作数据的权限,立即又加上锁。如此便能保证数据的安全准确。奇怪的是,在Python3中,即使不加锁,好像也不会发生数据出错的情况。或许这个例子不是很好,也或许是Python3中自动加了锁。希望有知道的读者赐教一下。这个奇怪的现象就是下例了:

from threading import Thread
import time

def add_one(a):
    time.sleep(1)
    print("in thread a:", a)
    a[1] += 1

if __name__ == '__main__':
    array = [0, 1, 4]
    thread_obj_list = []

    for i in range(50):
        t = Thread(target=add_one, args=(array,))
        t.start()
        thread_obj_list.append(t)

    for j in thread_obj_list:
        j.join()

    print("array result::", array)
    # array result:: [0, 51, 4]  

我们看到,最后array的第二个元素是51,并没有出错,这真是令人费解。好了,言归正传,来看看线程锁的几个方法吧:

lock = threading.Lock()     # Lock对象
lock.acquire()              # 锁定
lock.release()              # 解锁

Lock有“锁定”或“解锁”两种状态之一。它是在解锁状态下创建的。它有两个基本方法,acquire() 和 release()。 当状态为解锁时,acquire()将状态更改为锁定并立即返回。当状态被锁定时,acquire()块直到对另一个协程中的release()的调用将其改变为解锁,然后acquire()调用将其重置为锁定并返回。 release()方法只应在锁定状态下调用;它将状态更改为已解锁并立即返回。如果尝试释放已解锁的锁,则会引发 RuntimeError。

下面是一个具体的使用例子:

from threading import Thread
import time
import threading

lock = threading.Lock()

def add_one(a):
    time.sleep(1)
    lock.acquire()
    a[1] += 1
    lock.release()

if __name__ == '__main__':
    array = [0, 1, 4]
    thread_obj_list = []

    for i in range(50):
        t = Thread(target=add_one, args=(array,))
        t.start()
        thread_obj_list.append(t)

    for j in thread_obj_list:
        j.join()

    print("array result::", array)
    # array result:: [0, 51, 4]  

acquire()和release()方法成对出现。但是这样手动释放有时候可能会遗忘,这时候可以考虑用上下文管理协议。关于上下文管理协议,可参见作者的这篇文章【Python上下文管理器】。

Lock对象支持with语句:

def add_one(a):
    time.sleep(1)
    with lock:
        a[1] += 1 

3 递归锁 

可重入锁(又称递归锁,RLock),就是大锁中包含子锁的情况下使用。在这种情况下,再用Lock时,就会出现死锁现象,此时应该用threading.RLock()对象了,用法同Lock,参见下例:

from threading import Thread
import time
import threading

lock = threading.RLock()

def add_one(a):
    lock.acquire()
    a[1] += 1
    lock.release()

def add_two(b):
    time.sleep(1)
    lock.acquire()
    b[1] += 2
    add_one(b)
    lock.release()

if __name__ == '__main__':
    array = [0, 1, 4]
    thread_obj_list = []

    for i in range(50):
        t = Thread(target=add_two, args=(array,))
        t.start()
        thread_obj_list.append(t)

    for j in thread_obj_list:
        j.join()

    print("array result::", array)
    # array result:: [0, 151, 4]  

上例读者可以试试Lock(),看看什么效果。RLock()还支持上下文管理协议,上例中的两个函数可以改成这样:

def add_one(a):
    with rlock:
        a[1] += 1

def add_two(b):
    time.sleep(1)
    with rlock:
        b[1] += 2
        add_one(b)

4 GIL

全局解释器锁(英语:Global Interpreter Lock,缩写GIL),是计算机程序设计语言解释器用于同步线程的一种机制,它使得任何时刻仅有一个线程在执行。所以很多人说Python的线程是假线程,并能利用多核,并不能真正并行。之所以感觉到线程并行,是因为线程上下文不断切换的缘故。Python 3.2开始使用新的GIL。新的GIL实现中用一个固定的超时时间来指示当前的线程放弃全局锁。在当前线程保持这个锁,且其他线程请求这个锁时,当前线程就会在5毫秒后被强制释放该锁。关于全局锁,强调三点:

(1)GIL的存在,同一时刻只能有一个线程在运行。

(2)GIL是CPython的特性,Jython,pypy等并无GIL。

(3)Cpython的多线程适用于I/O密集型问题,计算密集型问题可使用多进程编程。 

5 判断线程状态

在多线程编程中,有时候某个线程依赖另一个线程的状态,需要使用threading库中的Event对象。 Event对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。可将线程设置等待Event对象, 直到有其他线程将Event对象设置为真,这些等待Event对象的线程将开始执行。Event()对象的常用方法:

event = threading.Event()   # 创建threading.Event()对象

event.is_set()   # 获取event的设置值,默认为False
event.set()      # 设置event的值为True
event.clear()    # 设置event的值为False
event.wait()     # 等到event的值被设为True就执行

下面通过“交通信号灯”问题示范event的使用:

import threading
import time

def traffic_light(event):
    count = 0
    event.set()
    while True:
        # 如果计数器[0, 5)之间, 红灯,event=False
        if 0 <= count < 5:
            event.clear()
            print("light is Red")
        # 如果计数器[5, 10)之间, 绿灯,event=True
        elif 5 <= count < 10:
            event.set()
            print("light is Green")
        # 如果计数器大于10,红灯,将event设置为False,计数器置为0
        else:
            event.clear()
            count = 0
        time.sleep(1)
        count += 1

def car(name, event):
    while True:
        if not event.is_set():
            # event为False, 表示红灯, 车只能等待
            print("RED, the %s is waiting..." % name)
            # 此处会阻塞住,直到event被设置为True在执行
            event.wait()
            print("Green, The %s going...." % name)

e = threading.Event()
light = threading.Thread(target=traffic_light, args=(e,))
light.start()
car1 = threading.Thread(target=car, args=("Tesla", e, ))
car1.start()

交通信号灯有红灯和绿灯两种状态,每5秒切换一次状态,而car()函数中,只要灯变绿就放car通行。运行试试看。

event对象的一个重要特点是当它被设置为真时会唤醒所有等待它的线程。如果你只想唤醒单个或者一定数目的线程,最好是使用信号量或者 Condition 对象来替代。

Condition对象

condition对象总是与锁关联,可以手动传入锁对象,也可以不传入使用默认值。当有多个线程需要等待某个变量改变时,才开始执行。这种情况可以用condition对象实现。condition对象的主要方法有:

condition = threading.Condition(lock=None)   # 创建Condition对象  参数可以不传

condition.acquire()    # 加锁
condition.release()    # 解锁

condition.wait(timeout=None)                 # 阻塞,直到有调用notify(),或者notify_all()时再触发
condition.wait_for(predicate, timeout=None)  # 阻塞,等待predicate条件为真时执行

condition.notify(n=1)        # 通知n个wait()的线程执行, n默认为1
condition.notify_all()       # 通知所有wait着的线程执行

with condition:              # 支持with语法,不必每次手动调用acquire()/release() 

看一个例子不是很优雅的例子:

import threading
import time

condition = threading.Condition()    # 创建condition对象

def func():
    condition.acquire()    # 如果没有with语句,必写这句,否者报错
    condition.wait()       # 阻塞,等待其他线程调用notify()
    print("in func..")
    condition.release()    # 与acquire()成对出现

# 启10个线程
for i in range(10):
    t = threading.Thread(target=func, args=())
    t.start()

time.sleep(5)

condition.acquire()
condition.notify(2)        # 通知两个线程执行
condition.release()

# in func..
# in func..
# 其他8个线程会继续等待... 

上例中,我们看到启动的10个线程会等待5秒钟并且调用了notify(2)之后,才会通知两个线程继续运行。且这两个线程执行完毕之后,其他8个线程仍然会阻塞在condition.wait() 处。

频繁写acquire() / release()很繁琐,下面是优雅的写法:

import threading
import time

condition = threading.Condition()    # 创建condition对象

def func(n):
    with condition:            # with更优雅
        condition.wait()       # 阻塞,等待其他线程调用notify()
        print("in func..", n)


# 启10个线程
for i in range(10):
    t = threading.Thread(target=func, args=(i,))
    t.start()

time.sleep(5)

with condition:
    condition.notify_all()        # 通知所有线程执行 

运行下,是不是等待5秒之后,所有线程都继续执行了?

7 信号量

信号量通常用于防范容量有限的资源,例如数据库服务器。一般而言信号量可以控制释放固定量的线程。比如启动100个线程,信号量的控制值设为5,那么前5个线程拿到信号量之后,其余线程只能阻塞,等到这5个线程释放信号量锁之后才能去拿锁。参见下例:

import threading
import time

def func(n):
    # semaphore.acquire()
    with semaphore:
        time.sleep(2)
        print("Thread::", n)
    # semaphore.release()

semaphore = threading.BoundedSemaphore(5)   # 信号量, 每次释放5个线程

thread_list = []
for i in range(23):
    t = threading.Thread(target=func, args=(i,))
    thread_list.append(t)
    t.start()

for j in thread_list:
    j.join()

print("all threads done") 

上例中,可以看到线程是每5个一组进行释放的。 

8 Barrier对象

Barriers字面意思是“屏障”,是Python线程(或进程)同步原语。每个线程中都调用wait()方法,当其中一个线程执行到wait方法处会立阻塞;一直等到所有线程都执行到wait方法处,所有线程再继续执行。参见下例:

import time
import threading

bar = threading.Barrier(3)  # 创建barrier对象,指定满足3个线程

def worker1():
    print("worker1")
    time.sleep(1)
    bar.wait()
    print("worker1 end")

def worker2():
    print("worker2")
    time.sleep(2)
    bar.wait()
    print("worker2 end")

def worker3():
    print("worker3")
    time.sleep(5)
    bar.wait()
    print("worker3 end")


thread_list = []
t1 = threading.Thread(target=worker1)
t2 = threading.Thread(target=worker2)
t3 = threading.Thread(target=worker3)
thread_list.append(t1)
thread_list.append(t2)
thread_list.append(t3)

for t in thread_list:
    t.start()

# 每个线程中都调用了wait()方法,在所有(此处设置为3)线程调用wait方法之前是阻塞的。
# 也就是说,只有等到3个线程都执行到了wait方法这句时,所有线程才继续执行。  

上例中,可以看到,所有线程会先各自运行wait()方法之前的代码,到wait()处阻塞。等待最后一个线程执行到wait()处,也就是5秒之后,所有线程恢复执行。

9 线程间通信

两个或多个线程之间相互发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个线程共享的 Queue 对象,线程通过使用 put()和 get()操作来向队列中添加或者删除元素。Queue对象已经内置了锁机制,编程时不必手动操作锁。下例producer()函数代表包子铺,生产包子放入队列中;consumer()函数代表吃包子的人,不断从队列中取出包子吃掉;以此演示线程间通过队列通信。

from queue import Queue
import threading
import time

q = Queue(10)

def producer():
    n = 0
    while True:
        q.put("包子%s" % n)
        print("包子铺生产 包子%s" % n)
        n += 1
        time.sleep(2)

def consumer():
    while True:
        r = q.get()
        print("bucker 吃掉 %s" % r)
        time.sleep(1)

t1 = threading.Thread(target=producer)
t1.start()
t2 = threading.Thread(target=consumer)
t2.start()  

形如上例的编程模型,又叫生产者-消费者模型。它降低了程序之前的耦合,使得队列的上游只关注生产数据,队列的下游只关注消费数据。在票务系统,或者资源有限的情况中可用此模型。补充两点:

(1)get() 和 put() 方法都支持非阻塞方式和设定超时。 (2)q.qsize() , q.full() , q.empty() 等可以获取一个队列的当前大小和状态。但它们不是线程安全的,尽量别用

10 线程池

Python3.2开始,增加了标准库concurrent.futures,该库中的ThreadPoolExecutor是自带的线程池。简单使用:

from concurrent.futures import ThreadPoolExecutor
import time

def tell(i):
    print("this is tread {}.".format(i))
    time.sleep(1)

if __name__ == '__main__':
    future = ThreadPoolExecutor(10)
    a = "ddd"
    for i in range(100):
        future.submit(tell, (i,))   # 添加一个线程到线程池
    future.shutdown(wait=True)      # 此函数用于释放异步执行操作后的系统资源。

其中,submit()方法第一个参数为函数名,第二个为函数的参数。shutdown(wait=True)用于释放异步执行操作后的系统资源。ThreadPoolExecutor还有一个优点就是:任务提交者更方便的从被调用函数中获取返回值。参见下例:

import concurrent.futures
import requests

URLS = ['http://www.cnblogs.com/zingp/p/5878330.html',
        'http://www.cnblogs.com/zingp/',
        'https://docs.python.org/']

# 爬取网页内容
def load_url(url, timeout):
    with requests.get(url, timeout=timeout) as conn:
        return conn.text

with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 创建future对象和对应的url的字典
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as err:
            print('url:%s -- err: %s' % (url, err))
        else:
            print(url, len(data))
            
# http://www.cnblogs.com/zingp/ 12391
# http://www.cnblogs.com/zingp/p/5878330.html 90029
# https://docs.python.org/ 9980   

上例创建一个大小为3的线程池,用了不少with语句,并用future.result() 获取函数返回值。最终,我们看到爬取了三个网页,并获得网页内容。future.result()操作会阻塞,直到对应的函数执行完成并返回一个结果。

此外,ThreadPoolExecutor还提供了异步回调的功能,大大简化了多线程编程中处理线程返回结果的难度,参见下例:

from concurrent.futures import ThreadPoolExecutor
import time
import threading

def tell(i):
    print("this is tread {}.".format(i))
    time.sleep(1)
    return [i, threading.get_ident()]   # 必须有返回,通过.result()拿到返回值

def callback(obj): 
    # obj 相当于传过来的future独享,且回调函数必须有这个参数
    result = obj.result()    # 线程函数的返回值
    print(result)

if __name__ == '__main__':
    future = ThreadPoolExecutor(10)
    a = "ddd"
    for i in range(100):
        # 线程运行结束后将future对象传给回调函数callback(obj)
        future.submit(tell, i,).add_done_callback(callback)   
    future.shutdown(wait=True)      # 此函数用于释放异步执行操作后的系统资源。

Python3.2以前并没有自带线程池,那时往往采用自定义线程池。下面一个就是自定义线程池的例子,看看是否能够看得懂:

import queue
import threading
import contextlib

StopEvent = object()

class ThreadPool(object):
    """定义一个线程池类。"""

    def __init__(self, max_num, max_task_num=None):
        if max_task_num:
            self.q = queue.Queue(max_task_num)
        else:
            self.q = queue.Queue()
        self.max_num = max_num
        self.cancel = False
        self.terminal = False
        self.generate_list = []
        self.free_list = []

    def run(self, func, args, callback=None):
        """
        线程池执行一个任务。
        :param func: 任务函数;
        :param args: 任务函数所需参数;
        :param callback: 任务执行失败或成功后执行的回调函数,回调函数有两个参数1、任务函数执行状态;
                            2、任务函数返回值(默认为None,即:不执行回调函数);
        :return: 如果线程池已经终止,则返回True否则None。
        """
        if self.cancel:
            return
        if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
            self.generate_thread()
        w = (func, args, callback,)
        self.q.put(w)

    def generate_thread(self):
        """
        创建一个线程。
        """
        t = threading.Thread(target=self.call)
        t.start()

    def call(self):
        """
        循环去获取任务函数并执行任务函数。
        """
        current_thread = threading.currentThread()
        self.generate_list.append(current_thread)

        event = self.q.get()
        while event != StopEvent:
            func, arguments, callback = event
            try:
                result = func(*arguments)
                success = True
            except Exception as e:
                success = False
                result = None

            if callback is not None:
                try:
                    callback(success, result)
                except Exception as e:
                    pass

            with self.worker_state(self.free_list, current_thread):
                if self.terminal:
                    event = StopEvent
                else:
                    event = self.q.get()
        else:
            self.generate_list.remove(current_thread)

    def close(self):
        """
        执行完所有的任务后,所有线程停止。
        """
        self.cancel = True
        full_size = len(self.generate_list)
        while full_size:
            self.q.put(StopEvent)
            full_size -= 1

    def terminate(self):
        """
        无论是否还有任务,终止线程。
        """
        self.terminal = True

        while self.generate_list:
            self.q.put(StopEvent)

        self.q.queue.clear()

    @contextlib.contextmanager
    def worker_state(self, state_list, worker_thread):
        """
        用于记录线程中正在等待的线程数。
        """
        state_list.append(worker_thread)
        try:
            # 遇到yield就返回回去执行with中的语句,执行完了回来。
            yield
        finally:
            state_list.remove(worker_thread)  

创建大的线程池的一个可能需要关注的问题是内存的使用。 例如,如果你在OS X系统上面创建2000个线程,系统显示Python进程使用了超过9GB的虚拟内存。 不过,这个计算通常是有误差的。当创建一个线程时,操作系统会预留一个虚拟内存区域来 放置线程的执行栈(通常是8MB大小)。但是这个内存只有一小片段被实际映射到真实内存中。 因此,Python进程使用到的真实内存其实很小 (比如,对于2000个线程来讲,只使用到了70MB的真实内存,而不是9GB)。如果担心虚拟内存大小,可以使用 threading.stack_size() 函数来降低它。

import threading
threading.stack_size(65536)

如果加上这条语句并再次运行前面的创建2000个线程试验, 会发现Python进程只使用到了大概210MB的虚拟内存,而真实内存使用量没有变。 注意线程栈大小必须至少为32768字节,通常是系统内存页大小(4096、8192等)的整数倍。

11 补充几个概念

同步的定义是:在发出一个功能调用时,在没有得到结果之前,该调用就不返回,同时其它线程也不能调用这个方法。按照这个定义,其实绝大多数函数都是同步调用。 但是通常说进程、线程同步,往往特指多进程、线程编程时,多个进程、线程之间协同步调,按预定的先后次序进行运行。比如线程A和线程B一起配合,A执行到一定程度依赖B的某个结果,于是停下来示意B运行,B开始执行,执行完将结果返回给A,A接着执行。这里的“同”应该理解为协同、协助、互相配合。 在多线程编程里面,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何时刻,最多有一个线程访问,以保证数据的完整性。

原语:前文提及原语,很多同学可能不了解这个名词的意思。内核或微核提供核外调用的过程或函数称为原语(primitive)。操作系统用语范畴。是由若干多机器指令构成的完成某种特定功能的一段程序,具有不可分割性。即原语的执行必须是连续的,在执行过程中不允许被中断。不同层次之间对话的语言称为原语,即不同层之间通过原语来实现信息交换。

12 小结与讨论

(1)Python多线程编程常用threading模块。启动一个多线程需要创建一个Thread对象,调用star()方法启动线程。注意is_alive() /join()方法和daemon参数的使用。 (2)python多线程锁有Lock / Rlock, 全局锁GIL。GIL是CPython特性,同一时刻只能运行一个线程,不能利用多核资源。 (3)线程同步原语有Event / Condition / Semaphore / Barrier。Event用于常用语通知全部线程,condition和Semapher常用于通知一定数量的线程, Barrier用于多个线程必须完成某些步骤再一起执行。 (4)Lock / Rlock / Event / Condition / Semaphore 支持上下文管理协议(with语句,好用)。 (5)线程间通信可以用queue模块中的Queue队列,get()和put()已加锁,是线程安全的。qsize()/full()/empty() 等可以获取一个队列的当前大小和状态, 不是线程安全的,尽量别用。 (6)concurrent.futures中的ThreadPoolExecutor是Python3.2之后自带的线程池模块,十分好用,支持with语句,通过future.result()获取线程返回值。 (7)Python多线程适用于I/O密集型问题,CPU密集型问题可以用C代码优化底层算法提升性能,需注意一个写的不好的C语言扩展会导致这个问题更加严重;也可以用pypy或者多进程。

以上是本篇全部内容,欢迎读者批评指正。

参考资料:

threading 官方文档

concurrent.futures 官方文档

Python3-cookbook 中文文档

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏CSDN技术头条

一图读懂JVM架构解析

本文阐述了JVM的构成和组件,配图清晰易懂,是学习Java开发者的入门必读文章。 每个Java开发人员都知道字节码经由JRE(Java运行时环境)执行。但他们或...

2198
来自专栏coder修行路

python中重要的模块--asyncio

一直对asyncio这个库比较感兴趣,毕竟这是官网也非常推荐的一个实现高并发的一个模块,python也是在python 3.4中引入了协程的概念。也通过这次整理...

4987
来自专栏orientlu

FreeRTOS 消息队列

上面这几中方式中, 除了消息通知, 其他几种实现都是基于消息队列。消息队列作为主要的通信方式, 支持在任务间, 任务和中断间传递消息内容。 这一章介绍 Fre...

4152
来自专栏Android 研究

Android系统启动——3init.rc解析

init.rc文件是以“块”(section)为单位服务的,,一个“块”(section)可以包含多行。“块”(section)分成两大类:一类称为"动作(ac...

3962
来自专栏张善友的专栏

自动类型安全的.NET标准REST库refit

1514
来自专栏抠抠空间

rest_framework之解析器、路由控制、分页

1690
来自专栏ml

Linux GDB常用命令一栏

Linux GDB 常用命令如下: 1.启动和退出gdb (1)启动:gdb ***:显示一段版权说明; (*** 表示可执行程序名) (2)退出:quit。有...

4084
来自专栏pangguoming

ElasticSearch客户端注解使用介绍

The best elasticsearch highlevel java rest api-----bboss

1073
来自专栏java一日一条

ava多线程:volatile变量、happens-before关系及内存一致性

请参考来自 Jean-philippe Bempel 的评论。他提到了一个真实因 JVM 优化导致死锁的例子。我尽可能多地写博客的原因之一是一旦自己理解错了,可...

772
来自专栏蓝天

从程序员角度看ELF

原文:http://xcd.blog.techweb.com.cn/archives/222.html

1014

扫码关注云+社区

领取腾讯云代金券