python学习总结2_多线程的实现

本文参照文章：python多线程实现
在理解的基础上手敲了一遍原文中的代码并运行。将局部内容做了些许修改使阅读起来更通顺。感谢原作者，用简易平实的描述讲清楚了多线程的基本原理和使用！

1.threading模块

# !/usr/bin/env python
# -*- coding: gbk -*-

import threading
import time

def test(name):
    print("线程运行",name)
    time.sleep(1)
    print("线程结束",name)

if __name__ == "__main__":
    t1 = threading.Thread(target=test,args = ("t1",))
    t2 = threading.Thread(target=test,args = ("t2",))

    t1.start()
    t2.start()

运行结果：

我们线程运行是t1,t2顺序，但是运行结束会出现t2，t1的顺序，原因是我们线程调度是由操作系统层面来进行操作的，它的资源分配是由OS来执行的，实际上它的底层是一种GIL锁资源抢占的方式。这个锁资源抢占不太懂，以后有机会可以细究。

2.自定义线程

通过继承threading.Thread来自定义线程类，其本质是重构Thread类中的run方法

# !/usr/bin/env python
# -*- coding: gbk -*-

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n = n

    def run(self):
        print("task run:",self.n)
        time.sleep(2)
        print("task finish:",self.n)

if __name__ == "__main__":
    t1 = MyThread(n="t1")
    t2 = MyThread(n="t2")

    t1.start()
    t2.start()

这个自定义线程我们一般用不到，除非你是需要在人家的基础上多增加一些实现的方法才用它。

3.守护线程

使用setDaemon(Ture)把所有的子线程都变成主线程的守护线程，当主线程结束后，子线程也随之结束，所以当主线程结束后，整个程序就退出了。

# !/usr/bin/env python
# -*- coding: gbk -*-

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__()
        self.n = n

    def run(self):
        print("task run:",self.n)
        time.sleep(2)
        print("task finish:",self.n)

if __name__ == "__main__":
    t1 = MyThread(n="t1")
    t2 = MyThread(n="t2")
    t1.setDaemon(True)
    t2.setDaemon(True)
    t1.start()
    t2.start()

运行结果：

结果我们发现和我们预想的不一样，只有run，却没有finish，因为设置了守护线程，所以主线程结束程序就结束了。
那我们如果要等子线程彻底运行完的话就要使用join方法，这个就是等待的意思，等待子线程全部运行结束再停止

if __name__ == "__main__":
    t1 = MyThread(n="t1")
    t2 = MyThread(n="t2")
    t1.setDaemon(True)
    t2.setDaemon(True)

    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("主线程运行结束")

4.全局变量

# !/usr/bin/env python
# -*- coding: gbk -*-

import threading
import time

g_num = 100

def work1():
    global g_num
    for i in range(3):
        g_num = g_num + 1
    print(g_num)

def work2():
    global g_num
    print(g_num)

if __name__ == "__main__":
    t1 = threading.Thread(target=work1)
    t1.start()
    time.sleep(1)
    t2 = threading.Thread(target=work2)
    t2.start()

程序中只是多了一个global，来声明一下这个g_num共享，如果没有这个global的话，程序就会错误，因为在程序觉得在子程序中找不到g_num这个变量
运行结果：

5.互斥锁

由于线程之间是随机调度，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁，我的理解就是，当多个线程进行资源抢占的时候，我这个线程在修改变量的时候，其他线程都不能进行修改，也不会把锁放开，只有我把操作全部完成之后，才会把锁放开。接下来我们看两个程序，分别就是用了互斥锁和没用互斥锁，我们比较一下他们的运行结果：
（1）没用互斥锁

# !/usr/bin/env python
# -*- coding: gbk -*-

from threading import Thread,Lock
import os,time

def work():
    global n
    temp = n
    time.sleep(0.1)
    n = temp - 1

if __name__ == "__main__":
    n = 100
    l = []
    for i in range(100):
        p = Thread(target = work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
    print(n)

运行结果：

（2）使用互斥锁

# !/usr/bin/env python
# -*- coding: gbk -*-

from threading import Thread,Lock
import os,time

def work():
    global n
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp - 1
    lock.release()

if __name__ == "__main__":
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        p = Thread(target = work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
    print(n)

运行结果：

没上锁的运行结果是99，上了锁的运行结果却是0，最终我们想要的结果应该是0，是99的原因是出现了线程安全的问题.

6.信号量

也就是我们通常说的几线程运行，我们设置最多允许几个线程同时运行，只有之前的运行完，把信号量交换回来，它才会继续运行

# !/usr/bin/env python
# -*- coding: gbk -*-

import threading
import os,time

def run(n,semaphore):
    semaphore.acquire()
    time.sleep(1)
    print(f"run the thread:{n}")
    semaphore.release()


if __name__ == "__main__":
    num = 0
    semaphore = threading.BoundedSemaphore(5)
    for i in range(22):
        t = threading.Thread(target=run,args=("t-%s"%i,semaphore))
        t.start()

    while threading.active_count()!=1:
        pass
    else:
        print("-----all threads done-----")

这个程序我们总共线程是21，但是最多同时运行的线程数只有5，因为我们设置的信号量是5。

完！