python基础：多线程

不念不忘少年蓝@ 2022-03-25 19:24 198阅读 0赞

**目录**

一、线程概念

二、创建多线程

1、使用threading模块创建线程

2、join()方法

3、setDaemon() 方法

4、实例方法

5、threading模块提供的方法

三、使用继承方式开启线程

四、线程之间共享全局变量

五、共享全局变量的问题

六、互斥锁

七、同步异步

--------------------

# **一、线程概念** #

由于进程是资源拥有者，创建、撤消与切换存在较大的内存开销，因此需要引入轻型进程即线程，进程是资源分配的最小单位,线程是CPU调度的最小单位（程序真正执行的时候调用的是线程）.每一个进程中至少有一个线程。

**进程和线程之间的关系可用下图表示：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIzOTU0MQ_size_16_color_FFFFFF_t_70][]

# **二、创建多线程** #

## **1、****使用threading模块创建线程** ##

给函数传递参数，使用线程的关键字 args=()进行传递参数，关键字以元组形式传参

import time
    import threading
    
    
    # 导入threading模块
    def sing():
        for i in range(3):
            print('正在唱歌', i)
            time.sleep(1)
    
    
    def dance():
        for i in range(3):
            print('正在跳舞...', i)
            time.sleep(1)
    
    
    def main():
        t1 = threading.Thread(target=sing)  # 创建t1子线程
        t2 = threading.Thread(target=dance)  # 创建t2子线程
        t1.start()  # 开启t1子线程
        t2.start()  # 开启t2子线程
    
    
    if __name__ == '__main__':
        main()
        print('程序结束了....')

运行结果：

正在唱歌 0
    正在跳舞... 0
    程序结束了....
    正在跳舞... 1
    正在唱歌 1
    正在跳舞... 2
    正在唱歌 2

执行顺序:

首先程序运行时，程序从上往下走，遇到main()函数然后开始执行，执行mian()函数的函数体时又创建了两个线程我们称之为子线程，程序运行时的线程我们称之为主线程

然后子线程根据target=xxx 开始执行指定的函数

(等子线程结束后主线程结束,程序结束了)

## **2、join()方法** ##

import time
    import threading
    
    
    # 导入threading模块
    def sing(num):
        for i in range(num):
            print('正在唱歌', i)
            time.sleep(1)
    
    
    def dance(num):
        for i in range(num):
            print('正在跳舞...', i)
            time.sleep(1)
    
    
    def main():
        t1 = threading.Thread(target=sing,args=(3,))  # 创建t1子线程,给num传递参数
        t2 = threading.Thread(target=dance,args=(3,))  # 创建t2子线程
        t1.start()  # 开启t1子线程
        t1.join()   # 等待t1执行完后才能向下执行，效果：t1执行完后，t2和主线程才执行
        t2.start()  # 开启t2子线程
        # t2.join()   # 当t1，t2子线程执行完后，主线程才执行
    
    if __name__ == '__main__':
        main()
        print('程序结束了....')

运行结果：

正在唱歌 0
    正在唱歌 1
    正在唱歌 2
    正在跳舞... 0
    程序结束了....
    正在跳舞... 1
    正在跳舞... 2

# #

## **3、setDaemon() 方法** ##

setDaemon()将当前线程设置成守护线程来守护主线程:

-当主线程结束后，守护线程也就结束，不管是否执行完成。

-应用场景：qq 多个聊天窗口，就是守护线程。

注意:需要在子线程开启的时候设置成守护线程，否则无效。

练习：创建简单的守护线程

运行结果：

正在唱歌 0
    正在跳舞... 0
    程序结束了....

练习：将上述两个子线程中的一个设置为守护线程，另一个不变

'''
    join方法功能：当前线程执行完后其他线程才能执行
    
    
    
    
    '''
    
    import time
    import threading
    
    
    # 导入threading模块
    def sing(num):
        for i in range(num):
            print('正在唱歌', i)
            time.sleep(1)
    
    
    def dance(num):
        for i in range(num):
            print('正在跳舞...', i)
            time.sleep(1)
    
    
    def main():
        t1 = threading.Thread(target=sing,args=(3,))  # 创建t1子线程,给num传递参数
        t2 = threading.Thread(target=dance,args=(3,))  # 创建t2子线程
        # 将t1和t2子线程设置为守护主线程
        t1.setDaemon(True)
        # t2.setDaemon(True)
        t1.start()
        t2.start()
    
    
    if __name__ == '__main__':
        main()
        print('程序结束了....')

运行结果：

正在唱歌 0
    正在跳舞... 0
    程序结束了....
    正在唱歌 1
    正在跳舞... 1
    正在唱歌 2
    正在跳舞... 2

运行过程;

虽然t1被设置为守护子线程，但是t2并不是，程序自上而下执行，等到子线程t2执行完之后主线程才会结束，在子线程t2执行期间，主线程并不会关闭，因此t1也不会关闭，会继续执行,直到t2执行完毕。

## **4、实例方法** ##

线程对象的一些实例方法，了解即可

\- getName(): 获取线程的名称。

\- setName(): 设置线程的名称。

\- isAlive(): 判断当前线程存活状态。

import time
    import threading
    
    
    # 导入threading模块
    def sing(num):
        for i in range(num):
            print('正在唱歌', i)
            time.sleep(1)
    
    
    def dance(num):
        for i in range(num):
            print('正在跳舞...', i)
            time.sleep(1)
    
    
    def main():
        t1 = threading.Thread(target=sing, args=(3,))  # 创建t1子线程,给num传递参数
        t2 = threading.Thread(target=dance, args=(3,))  # 创建t2子线程
        # print(t1.is_alive())  # False  子线程未开启,为False
        # print(t2.isAlive())   # False
        t1.start()
        print(t1.is_alive())  # True
        t2.start()
        # 获取线程名称
        # print(t1.getName())  # Thread-1
        # print(t2.getName())  # Thread-2
        # 给线程设置名称
        # t1.setName('张飞')
        # t1.setName('关羽')
        # print(t1.getName())  # 张飞
        # print(t2.getName())  # 关羽
    
    if __name__ == '__main__':
        main()
        print('程序结束了....')

运行结果：

False
    False
    正在唱歌 0
    True
    正在跳舞... 0
    Thread-1
    Thread-2
    程序结束了....
    正在唱歌 1
    正在跳舞... 1
    正在唱歌 2
    正在跳舞... 2

## 5、**threading模块提供的方法** ##

threading.currentThread(): 返回当前的线程变量。

threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

import time
    import threading
    
    
    # 导入threading模块
    def sing(num):
        for i in range(num):
            print('正在唱歌', i)
            time.sleep(1)
    
    
    def dance(num):
        for i in range(num):
            print('正在跳舞...', i)
            time.sleep(1)
    
    
    def main():
        t1 = threading.Thread(target=sing, args=(3,))
        t2 = threading.Thread(target=dance, args=(3,))
    
        t1.start()
        t2.start()
        print(threading.current_thread())  # 返回当前的线程变量
        print(threading.enumerate())   # 返回当前在正在运行线程的列表
        print(threading.active_count())  # 返回当前活着的线程的数量
    
    
    if __name__ == '__main__':
        main()
        print('程序结束了....')

运行结果：

正在唱歌 0
    正在跳舞... 0
    <_MainThread(MainThread, started 9456)>
    [<_MainThread(MainThread, started 9456)>, <Thread(Thread-1, started 10052)>, <Thread(Thread-2, started 9324)>]
    3
    程序结束了....
    正在唱歌 1
    正在跳舞... 1
    正在跳舞... 2
    正在唱歌 2

# 三、**使用继承方式开启线程** #

1.  定义一个类继承threading.Thread类。
2.  复写父类的run()方法。

import threading
    import time
    
    # 继承threading.Thread类
    class MyThread(threading.Thread):
        def __init__(self,num):
            super().__init__() # 调用父类的init方法
            self.num=num
        # 复写父类的run方法
        def run(self):
            for i in range(self.num):
                print('i--->',i)
                time.sleep(1)
    
    if __name__ == '__main__':
        my_thread=MyThread(3)   # 创建对象
        my_thread.start()   # 开启子线程

运行结果：

i---> 0
    i---> 1
    i---> 2

# 四、**线程之间共享全局变量** #

import threading,time
    g_num = 10
    
    def test1():
        global g_num   # 修改全局变量的值
        g_num+=1
        print('test1---->',g_num)   # 11
    
    def test2():
        print('test2---->',g_num)   # 11
    
    def main():
        t1=threading.Thread(target=test1)
        t2=threading.Thread(target=test2)
        t1.start()
        time.sleep(1)
        t2.start()
    
    if __name__ == '__main__':
        main()

运行结果：

test1----> 11
    test2----> 11

# 五、**共享全局变量的问题** #

多线程开发的时候共享全局变量会带来资源竞争效果。也就是数据不安全。

import threading, time
    
    g_num = 0
    
    
    # 多个线程同时操作共享全局变量,就会造成数据不安全
    def test1(num):
        global g_num
        for i in range(num):
            g_num += 1
    
        print('test1--->', g_num)
    
    
    def test2(num):
        global g_num
        for i in range(num):
            g_num += 1
    
        print('test2--->', g_num)
    
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=test1, args=(1000000,))
        t2 = threading.Thread(target=test2, args=(1000000,))
        t1.start()
        t2.start()

运行结果：

test1---> 11640721
    test2---> 11866119

由于运算过程较长，会存在t1过程没有结束，而t1运算的结果被t2运算的结果覆盖掉的情况

# 六、**互斥锁** #

当多个线程几乎同时修改一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全的访问竞争资源(全局内容)，最简单的同步机制就是使用互斥锁。某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定状态，其他线程就能更改，直到该线程将资源状态改为非锁定状态，也就是释放资源，其他的线程才能再次锁定资源。互斥锁保证了每一次只有一个线程进入写入操作。从而保证了多线程下数据的安全性。

import threading
    
    g_num = 0
    
    def test1(num):
        global g_num
        lock.acquire()  # 加锁
        for i in range(num):
            g_num += 1
        lock.release()  # 释放锁
        print('test1--->', g_num)
    
    
    def test2(num):
        global g_num
        lock.acquire()  # 加锁
        for i in range(num):
            g_num += 1
        lock.release()  # 释放锁
        print('test2--->', g_num)
    
    
    lock = threading.Lock() # 创建锁对象
    
    if __name__ == '__main__':
        t1 = threading.Thread(target=test1, args=(1000000,))
        t2 = threading.Thread(target=test2, args=(1000000,))
        t1.start()
        t2.start()

运行结果：

test1---> 1000000
    test2---> 2000000

# 七、**同步异步** #

同步：

同步的意思就是协同步调，按预定的先后次序执行。例如你先说完然后我再说。

例如线程同步，可以理解为线程A和B一块配合工作，A执行到一定程度时要依靠B的某个结果，于是停下来示意B执行，B执行完将结果给A,然后A继续执行。

A强依赖B(对方)，A必须等到B的回复，才能做出下一步响应。即A的操作(行程)是顺序执行的，中间少了哪一步都不可以，或者说中间哪一步出错都不可以。

异步：

异步则相反，A并不强依赖B，A对B响应的时间也不敏感，无论B返回还是不返回，A都能继续运行；B响应并返回了，A就继续做之前的事情，B没有响应，A就做其他的事情。也就是说A不存在等待对方的概念。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDIzOTU0MQ_size_16_color_FFFFFF_t_70]: /images/20220325/7775f20e9d6d4612a285ec13c33162a9.png