初识python多线程

参考：

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锁，互不影响。

Thread类构造方法

Thread(group = None, target = None, name = None, args = (), kwargs = {})

group：线程组，目前尚未实现，必须是None。
target：要执行的方法。
name：线程名。（默认是Thread-number）
args/kwargs：要传入方法的参数。

实例方法

isAlive()：返回线程是否在运行。

get/setName：获取/设置线程名。

start()：启动线程

is/setDaemon(bool)：获取/设置是后台进程（默认是前台进程（False））。

如果是后台进程，主线程执行过程中，后台线程也在进行，主线程执行完毕之后，后台线程不论成功与否，主线程和后台线程均停止。

如果是前台线程，主线程执行过程中，前台线程也在执行，主线程执行完毕后，等待前台线程执行完成后，程序停止。

join()：阻塞当前上下文环境的线程，知道调用此方法的线程终止或者到达指定的timeout（可选参数）。

创建线程的两种方法

方法1：将想要执行的方法传给Thread类中的构造方法。
方法2：定义一个新类继承Thread类，重写run方法。

# 创建线程的两种方法

# 第一种：将要执行的方法传给Thread的构造方法

import threading

import time

def run(n):

    time.sleep(1)

    print(n)

for i in range(5):

    t = threading.Thread(target = run, args = (i,))

    t.start()

# 第二种，继承Thread类，重写run()方法

class Mythread(threading.Thread):

    def __init__(self, arg):

        threading.Thread.__init__(self)

        # super().__init__(self)

        self.arg = arg

    def run(self):

        time.sleep(1)

        print(self.arg)

for i in range(5,10):

    t = Mythread(i)

    t.start()

setDeamon方法

设置是后台进程（True）还是前台进程（False）。（默认是False）

例题如下：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import threading

import time

class Mythread(threading.Thread):

    def __init__(self, arg, name):

        threading.Thread.__init__(self, name=name)

        # super().__init__(self)

        self.arg = arg

    def run(self):

        time.sleep(3)

        print(self.arg)

thread = Mythread(10, 'TestThread')

# thread.setDaemon(True)

thread.start()

for i in range(2):

    print(threading.current_thread().name + ': ', i)

    # 判断子线程是不是存活

    print(thread.name + ': ', thread.isAlive())

    time.sleep(1)

输出：

MainThread:  0

TestThread:  True

MainThread:  1

TestThread:  True

10

在线程启动前，设置：

thread.setDaemon(True)

输出：

MainThread:  0

TestThread:  True

MainThread:  1

TestThread:  True

可以看到，子线程并没有完全进行完毕，因为这时主线程已经结束了，子线程也要跟着结束。

join方法

阻塞线程上下文，直到调用此方法的线程终止或到达指定的timeout，即使设置了setDeamon(True)的主线程也要等待子线程结束。

实例如下：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import threading

import time

class Mythread(threading.Thread):

    def __init__(self, arg, name):

        threading.Thread.__init__(self, name=name)

        # super().__init__(self)

        self.arg = arg

    def run(self):

        time.sleep(1)

        print(self.name + ': ', self.arg)

thread = Mythread(10, 'TestThread')

for i in range(5):

    t = Mythread(i, 'Thread' + str(i))

    t.start()

    # t.join()



输出（比较乱，因为停顿1s后，所有的线程都在准备就绪的状态）：

```python

Thread2:  2

Thread4:  Thread1: Thread0:  0Thread3:  3

 1

4

我们在每个线程的后面，用join方法进行阻塞，如下：

t.join()

输出：

Thread0:  0

Thread1:  1

Thread2:  2

Thread3:  3

Thread4:  4

Lock类、Rlock类

由于线程之间的随机调度：某个线程可能在执行n条后，CPU接着执行其他线程。为了防止多个线程同时操作一个内存资源时造成混乱，我们使用了锁。

例如，我们同时使用两个线程操作一个全局变量，如下：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import threading

class Mythread(threading.Thread):

    def __init__(self, name, i):

        threading.Thread.__init__(self, name=name)

        self.i = i

    def run(self):

        global count

        for i in range(100000):

            count -= self.i

            count += self.i

count = 10

t1 = Mythread('Thread' + str(1) + ': ', 100)

t2 = Mythread('Thread' + str(2) + ': ', 50)

t1.start()

t2.start()

t1.join()

t2.join()

print('count = ', count)

在运行次数比较少的时候，可以输出正确答案，但是当循环次数变大之后，每次输出的结果就不一样了。

但是，当我们使用了Lock类之后，如下：

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import threading

import time

class Mythread(threading.Thread):

    def __init__(self, name, i):

        threading.Thread.__init__(self, name=name)

        self.i = i

    def run(self):

        global count

        for i in range(100000):

            lock.acquire()    # 获取锁

            count -= self.i

            count += self.i

            lock.release()    # 释放锁

count = 10

lock = threading.Lock()

t1 = Mythread('Thread' + str(1) + ': ', 100)

t2 = Mythread('Thread' + str(2) + ': ', 50)

t1.start()

t2.start()

t1.join()

t2.join()

print('count = ', count)

Lock类与RLock类的区别。

这两种锁的主要区别是：在同一线程内，对RLock进行多次acquire()操作，程序不会阻塞。

threading.Lock() 加载线程的锁对象，是一个基本的锁对象，一次只能一个锁定，其余锁请求，需等待锁释放后才能获取

threading.RLock() 多重锁，在同一线程中可用被多次acquire。如果使用RLock，那么acquire和release必须成对出现。