多任务之线程

最新推荐文章于 2021-02-10 16:45:02 发布

FXHaoo

最新推荐文章于 2021-02-10 16:45:02 发布

阅读量264

点赞数

分类专栏： python 文章标签： python threading 线程

本文链接：https://blog.csdn.net/weixin_43616727/article/details/89739687

版权

python 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

多任务之线程

多任务，顾名思义就是多个任务同时进行，多任务又有并行和并发，并行是真正的多任务（即一个CPU执行一个任务），但现在电脑大部分是4核，并没有那么多的CPU去执行任务，这时就用到了并发（时间片轮转，任务轮流让CPU执行），由于切换速度很快，我们就会感觉多个任务在同时执行。

线程

threading 模块的使用

import threading

def test1():
	pass   
   
def test2():
    pass

def main():
   t1 = threading.Thread(traget=test1)
   t2 = threading.Thread(traget=test2)
   t1.start()
   t2.start()

if __name__ == '__main__':
    main()

注：调用 Thread时，不会创建子线程，只是创建了一个对象，当这个对象调用 star() 时，子线程才会被建立并启动。

子线程线程在对象函数执行完毕后就会自动结束，而主线程必须在子线程完成后在结束，不然子线程会提前结束。

线程的数量

使用 threading 中的 enumerate() 方法。

length = len(threading.enumerate())
print("当前运行线程数为：%d " % length)

用类封装线程代码

为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法

import threading

class Test(threading.Thread):
   def run(self):  # 这里必须用run
        print("这里运行代码。。。。。。")
        self.login()
        self.use()

    def login(self):
        print("这是登录的代码。。。。。")

    def use(self):
      print("这是使用的代码。。。。。")
      
if __name__ == '__main__':
    t = Test()
    t.start()     # 调用start()方法时，会直接运行run()方法

注：若类里面有多个方法，调用start()时，不会主动运行，需在 run()方法内自身调用方法

多线程的执行顺序是不确定的

多线程共享全局变量

函数里修改全局变量

num = 100
nums = [100, 200]

def tset1():
	global num
	num += 100
   
def test2():
	nums.append(300)

在一个函数中，对全局变量进行修改时，到底要不要用global，这就要看是否对全局变量标签指向进行了修改，若修改了指向，即全局变量标签指向了一个新的地方，那么久要用global进行声明，若只是修改了全局变量标签指向空间的数据时，就不必使用global进行声明

多线程里的共享全局变量

import threading
import time

g_num = 100  # 定义一个全局变量

def test1():
    global g_num
    g_num += 1
    print("---在test1里  g_num = %d ---" % g_num)

def test2():
    print("---在test2里  g_num = %d ---" % g_num)

def main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)

    t1.start()
    time.sleep(1)

    t2.start()
    time.sleep(1)

    print("---在main里  g_num = %d ---" % g_num)

print("---创建线程前的 g_num = %d " % g_num)

if __name__ == '__main__':
    main()

在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据

共享全局变量的问题

多个线程可以共享一个变量，意味着它们可以随意修改该变量，若它们都在同一时间修改，这就造成了一个问题——资源竞争，从而导致全局变量的值混乱

import threading
import time

g_num = 0

def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----在test1中 g_num = %d " % g_num)

def test2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----在test2中 g_num = %d " % g_num)

def main():
    t1 = threading.Thread(target=test1, args=(1000000,))  # 加逗号是因为传递的是列表
    t1.start()

    t2 = threading.Thread(target=test2, args=(1000000,))
    t2.start()
  
    time.sleep(3)  # # 等待上面两个线程执行完毕。。

    print("----在main中 g_num = %d " % g_num)
      
if __name__ == '__main__':
    main()

上程序中 g_num 的值理论应该为 2000000，但实际结果却是小于2000000，这就是资源竞争带来的问题

互斥锁

解决上面资源竞争带来的问题，可以先让一个线程完成对全局变量的修改，在让另一个线程对局部变量的修改
threading模块中定义了LOCK类，可以方便的处理锁定

互斥锁的使用

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire()

# 释放
mutex.release()

注意：如果这个锁这前没有上锁，那么acquire不会堵堵塞，反之就会堵塞，直至该锁解锁为止

互斥锁解决问题

import threading
import time

# 定义一个全局变量
g_num = 0
# 创建互斥锁,默认没有上锁
mutex_lock = threading.Lock()

def test1(num):
    global g_num
    # 上锁，如果之前没有被上锁，那么就会上锁
    # 若之前已经被上锁，那么此时就会被堵塞在这，等待之前的锁解开
    mutex_lock.acquire()
    for i in range(num):
        g_num += 1
    # 解锁
    mutex_lock.release()
    print("----在test1中 g_num = %d " % g_num)

def test2(num):
    global g_num
    mutex_lock.acquire()
    for i in range(num):
        g_num += 1
    mutex_lock.release()
    print("----在test2中 g_num = %d " % g_num)

def main():
    t1 = threading.Thread(target=test1, args=(10000000,))
    t1.start()

    t2 = threading.Thread(target=test2, args=(10000000,))
    t2.start()

    # 等待上面两个线程执行完毕。。。
    time.sleep(3)

    print("----在main中 g_num = %d " % g_num)

if __name__ == '__main__':
    main()