多任务----线程

阿公带你飞。

于 2019-07-08 16:19:15 发布

阅读量83

点赞数

本文链接：https://blog.csdn.net/weixin_44872216/article/details/95063967

版权

多任务

什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。

并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的

线程

1. 使用threading模块

import threading


def sing():
	pass


def dance():
	pass


def main():
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()


if __name__ == "__main__":
    main()

当调用 start() 时，才会真正的创建线程，并且开始执行

2. 查看线程数

使用 threading 中的 enumerate() 方法。

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

3. 线程执行代码的封装

为了让每个线程的封装性更完美，所以使用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() 方法内自身调用方法，多线程的执行顺序是不确定的

`4. 多线程-共享全局变量（重点）`

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

import threading
import time

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


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


def test2():
    print("-----in 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("-----in main Thread g_num = %d -----" % g_num)

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


if __name__ == "__main__":
    main()

在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）

5.多线程-共享全局变量问题

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

import threading
import time

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


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


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


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

    t1.start()
    t2.start()

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

    print("-----in main Thread g_num = %d -----" % g_num)


if __name__ == "__main__":
    main()

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

6.互斥锁

为了解决上述的资源竞争问题，互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
threading模块中定义了Lock类，可以方便的处理锁定
- 创建锁
  mutex = threading.Lock()
- 锁定
  mutex.acquire()
- 释放
  mutex.release()

注意：

如果这个锁之前是没有上锁的，那么acquire不会堵塞，相反的那么此时acquire会堵塞，直到这个锁被解锁为止

用互斥锁解决资源竞争的问题

import threading
import time

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


def test1(num):
    global g_num
    # 上锁 如果之前没有被上锁 那么上锁成功
    # 如果之前上锁成功，那么此时会在这堵塞，直到这个所被解开

    for i in range(num):
        mutex.acquire()
        g_num += 1
    # 解锁
        mutex.release()
    print("-----in test1 g_num=%d-----" % g_num)


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


# 创建一个互斥锁 默认没有上锁
mutex = threading.Lock()


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

    t1.start()
    t2.start()

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

    print("-----in main Thread g_num = %d -----" % g_num)


if __name__ == "__main__":
    main()