多任务
什么叫“多任务”呢?简单地说,就是操作系统可以同时运行多个任务。
- 并发:指的是任务数多余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()
上锁解锁过程
当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。
每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“阻塞”,直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入“unlocked”状态。
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。