python多线程

本文重点探究以下几个问题：

• 多线程内存共享
• 线程类
• 获取线程结果
• 方法：join/setDaemon对线程退出的作用
• 线程无法利用多核，不是真正的并发

多线程内存共享

多个线程访问同一内存变量时，需要通过锁机制来实现，未使用锁的多线程代码如下： 

import time, threading

# 假定这是你的银行存款:
balance = 0

def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

运行后发现，打印结果可能不为0，使用threading.Lock加锁，一般使用with对锁进行管理，自动获取和释放：

lock = threading.Lock()

def run_thread(n):
    for i in range(100000):
        with lock:
            change_it(n)

也可以手动控制：

def run_thread(n):
    for i in range(100000):
        lock.acquire()
        try:
            change_it(n)
        finally:
            lock.release()

线程类

需要继承threading.Thread类，重写run方法，这里提供一种通用线程类的实现方式：

import threading


class MyThread(threading.Thread):

    def __init__(self, func, args, name=''):
        threading.Thread.__init__(self)
        self._func = func
        self._result = None
        self._args = args
        self._name = name

    def run(self):
        _result = self._func(*self._args)
        self._result = _result

    @property
    def result(self):
        return self._result


def add(a, b):
    return a + b


def multiply(a, b):
    return a * b

threads = [MyThread(add, args=(1, 2,)),
           MyThread(multiply, args=(1, 2,))]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

for thread in threads:
    print(thread.result)  # 分别打印3和2

 

获取线程结果

一般有2种实现方式，第一个是线程读写全局变量来完成，另一个是通过线程类属性实现。

以上通过@properity属性，获取result。这样通过线程对象，即可获取各线程内部结果

join/setDaemon对线程退出的作用

1 等待时间为各线程join时间之和

2 join超时之后，程序继续向下运行，后台守护线程判断当前是否存在非守护线程，若存在，则所有未完成线程继续运行，否则若只有守护线程，则不管守护线程是否在运行都要结束本身。

线程无法利用多核，不是真正的并发

以下内容参考廖雪峰python教程

因为Python的线程虽然是真正的线程，但解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

GIL是Python解释器设计的历史遗留问题，通常我们用的解释器是官方实现的CPython，要真正利用多核，除非重写一个不带GIL的解释器。

所以，在Python中，可以使用多线程，但不要指望能有效利用多核。如果一定要通过多线程利用多核，那只能通过C扩展来实现，不过这样就失去了Python简单易用的特点。

不过，也不用过于担心，Python虽然不能利用多线程实现多核任务，但可以通过多进程实现多核任务。多个Python进程有各自独立的GIL锁，互不影响。