Python——多线程
作者:互联网
1.多线程
多线程类似于同时执行多个不同程序。
多线程运行有如下优点:
- 使用线程可以把占据长时间的程序中的任务放到后台去处理;
- 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度;
- 程序的运行速度可能加快;
- 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等,线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器,称为线程的上下文,该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器,线程总是在进程得到上下文中运行的,这些地址都用于标志拥有线程的进程地址空间中的内存。
- 线程可以被抢占(中断)。
- 在其他线程正在运行时,线程可以暂时搁置(也称为睡眠)——即线程的退让。
线程的分类:
- 内核线程:由操作系统内核创建和撤销。
- 用户线程:不需要内核支持而在用户程序中实现的线程。
2.Python线程
Python中使用线程有两种方式:函数或者用类来包装线程对象。
(1)函数式:
调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:
_thread.start_new_thread(function, args[, kwargs])
参数说明:
- function:线程函数。
- args:传递给线程函数的参数,他必须是个tuple类型。
- kwargs:可选参数。
例:
import _thread
import time
# 为线程定义一个函数
def print_time(threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print("%s: %s" % (threadName, time.ctime(time.time())))
# 创建两个线程
try:
_thread.start_new_thread(print_time, ("Thread-1", 2,))
_thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
print("Error: Unable to start thread")
while 1:
pass
运行结果:
Thread-1: Thu Jan 20 20:11:36 2022
Thread-2: Thu Jan 20 20:11:38 2022
Thread-1: Thu Jan 20 20:11:38 2022
Thread-1: Thu Jan 20 20:11:40 2022
Thread-2: Thu Jan 20 20:11:42 2022
Thread-1: Thu Jan 20 20:11:42 2022
Thread-1: Thu Jan 20 20:11:44 2022
Thread-2: Thu Jan 20 20:11:46 2022
Thread-2: Thu Jan 20 20:11:50 2022
Thread-2: Thu Jan 20 20:11:54 2022
线程的结束:
- 一般依靠线程函数的自然结束;
- 在线程函数中调用thread.exit(),抛出SystemExit exception,达到退出线程的目的。
3.线程模块
Python3 通过两个标准库_thread和threading提供对线程的支持。
(1)_thread:
提供了低级别的、原始的线程以及一个简单的锁,它相比于threading模块的功能还是比较有限的。
(2)threading模块:
除了包含_thread模块中的所有方法外,还提供的其他方法:
- threading.currentThread():返回当前的线程变量。
- threading.enumerate():返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
- threading.activeCount():返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。
(3)Thread类:
除了使用方法外,线程模块同样提供了Thread类来处理线程,Thread类提供了以下方法:
- run():用以表示线程活动的方法。
- start():启动线程活动。
- join([time]):等待至线程中止。这阻塞调用线程直至线程的join()方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
- isAlive():返回线程是否活动的。
- getName():返回线程名。
- setName():设置线程名。
(4)使用threading模块创建线程:
通过直接从threading.Thread继承创建一个新的子类,并实例化后调用start()方法启动新线程,即它调用了线程的run()方法。
例:
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, delay):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.delay = delay
def run(self):
print ("开始线程:" + self.name)
print_time(self.name, self.delay, 5)
print ("退出线程:" + self.name)
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")
运行结果:
开始线程:Thread-1
开始线程:Thread-2
Thread-1: Wed Jan 5 17:34:54 2022
Thread-2: Wed Jan 5 17:34:55 2022
Thread-1: Wed Jan 5 17:34:55 2022
Thread-1: Wed Jan 5 17:34:56 2022
Thread-2: Wed Jan 5 17:34:57 2022
Thread-1: Wed Jan 5 17:34:57 2022
Thread-1: Wed Jan 5 17:34:58 2022
退出线程:Thread-1
Thread-2: Wed Jan 5 17:34:59 2022
Thread-2: Wed Jan 5 17:35:01 2022
Thread-2: Wed Jan 5 17:35:03 2022
退出线程:Thread-2
退出主线程
4.延时函数
(1)库:
import time
(2)函数:
time.sleep(seconds)
(3)参数:
seconds延迟执行代码的秒数
例:
import time
while(1):
print("Hello!geigei!")
time.sleep(1)
5.锁
Threading模块为我们提供了一个类,threading.Lock锁。当创建一个该类对象,在线程函数执行前,“抢占”该锁,执行完成后,“释放”该锁,确保每次只有一个线程占有该锁。这样对一个公共的对象进行操作时,则不会发生线程不安全的现象。
(1)线程锁(Lock):
建立一个threading.Lock类对象lock,在run()方法中使用lock.acquire()获得该锁,则其他的线程就无法再获得该锁,就会阻塞在“if lock.acquire()”处,直到该锁被另一个线程释放:lock.release()。
如果多个线程要调用多个现象,而A线程调用A锁占用了A对象,B线程调用B锁占用了B对象,A线程不能调用B对象,B线程不能调用A对象,则一直等待。这就造成了线程“死锁”。
(2)递归锁(RLock):
又可称为可重入锁,该锁对象内部维护着一个Lock和一个counter对象。
counter对象记录了acquire的次数,使得资源可以被多次require,最后当所有RLock被release后,其他线程才能获取资源。在同一个线程中,RLock.acquire可以被多次调用,利用该特性,可以解决部分死锁问题。
语法:
lock = threading.Lock() # 创建线程锁
lock = threading.RLock() # 创建递归锁(多个锁时用这个)
lock.acquire() # 锁住
lock.release() # 释放锁
例:
线程锁:
# 线程锁,加锁实例
import threading
import time
def chiHuoGuo(people, do):
print("%s 吃火锅的小伙伴:%s" % (time.ctime(),people))
time.sleep(1)
for i in range(3):
time.sleep(1)
print("%s %s正在 %s 鱼丸"% (time.ctime(), people, do))
print("%s 吃火锅的小伙伴:%s" % (time.ctime(),people))
# 继承父类threading.Thread
class myThread (threading.Thread):
lock = threading.Lock() # 线程锁
def __init__(self, people, name, do):
'''重写threading.Thread初始化内容'''
threading.Thread.__init__(self)
self.threadName = name
self.people = people
self.do = do
# 把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
def run(self):
'''重写run方法'''
print("开始线程: " + self.threadName)
# 执行任务之前锁定线程
self.lock.acquire()
chiHuoGuo(self.people, self.do) # 执行任务
# 执行完之后,释放锁
self.lock.release()
print("结束线程: " + self.name)
print("yoyo请小伙伴开始吃火锅:!!!")
# 设置线程组
threads = []
# 创建新线程
thread1 = myThread("xiaoming", "Thread-1", "添加")
thread2 = myThread("xiaowang", "Thread-2", "吃掉")
# 添加到线程组
threads.append(thread1)
threads.append(thread2)
# 开启线程
for thread in threads:
thread.start()
# 阻塞主线程,等子线程结束
for thread in threads:
thread.join()
time.sleep(0.1)
print("退出主线程:吃火锅结束,结账走人")
运行结果:
yoyo请小伙伴开始吃火锅:!!!
开始线程: Thread-1
Fri Mar 15 08:36:39 2019 吃火锅的小伙伴:xiaoming
开始线程: Thread-2
Fri Mar 15 08:36:41 2019 xiaoming正在 添加 鱼丸
Fri Mar 15 08:36:42 2019 xiaoming正在 添加 鱼丸
Fri Mar 15 08:36:43 2019 xiaoming正在 添加 鱼丸
Fri Mar 15 08:36:43 2019 吃火锅的小伙伴:xiaoming
结束线程: Thread-1
Fri Mar 15 08:36:43 2019 吃火锅的小伙伴:xiaowang
Fri Mar 15 08:36:45 2019 xiaowang正在 吃掉 鱼丸
Fri Mar 15 08:36:47 2019 xiaowang正在 吃掉 鱼丸
Fri Mar 15 08:36:48 2019 xiaowang正在 吃掉 鱼丸
Fri Mar 15 08:36:48 2019 吃火锅的小伙伴:xiaowang
结束线程: Thread-2
退出主线程:吃火锅结束,结账走人
递归锁:
#线程锁,多个锁时,需加递归锁
import threading
import time
def run1():
print("grab the first part data")
lock.acquire()
global num
num += 1
lock.release()
return num
def run2():
print("grab the second part data")
lock.acquire()
global num2
num2 += 1
lock.release()
return num2
def run3():
lock.acquire()
res = run1()
print('--------between run1 and run2-----')
res2 = run2()
lock.release()
print(res, res2)
num, num2 = 0, 0
lock = threading.RLock() #递归锁
for i in range(3):
t = threading.Thread(target=run3)
t.start()
while threading.active_count() != 1:
print(threading.active_count())
else:
print('----all threads done---')
print(num, num2)
运行结果:
grab the first part data
--------between run1 and run2-----
grab the second part data
1 1
grab the first part data
--------between run1 and run2-----
grab the second part data
2grab the first part data
--------between run1 and run2-----
2
3grab the second part data
3 3
----all threads done---
3 3
6.案例
在一个线程中,每秒循环输出当前的年月日时分秒;于此同时, 在另一个线程中,实现张三的姓名每2秒打印输出4次结束。注意: 都需要使用类和继承实现功能。
多线程:Thread
'''
1.多线程
要求:
在一个线程中,每秒循环输出当前的年月日时分秒;于此同时,在另一个线程中,实现张三的姓名每2秒打印输出4次结束。
注意:都需要使用类和继承实现功能。
'''
import threading
import time
# 在第一个线程中,每秒循环输出当前的年月日时分秒
class Print_Time(threading.Thread):
def run(self):
while True:
# 每隔1s获取当地时间并打印一次
location_time = time.asctime(time.localtime(time.time()))
print(location_time)
# 每次延时1s
time.sleep(1)
# 在第二个线程中,实现姓名每2秒打印输出4次结束
class Print_Name(threading.Thread):
# 构造方法,继承threading.Thread,并实例化
def __init__(self, name):
# 继承父类的方法
super(Print_Name, self).__init__()
# 实例化对象属性
self.name = name
# 重写父类中的run方法
def run(self):
# 用for语句循环实现两秒内打印4次张三的名字后结束
for i in range(4):
print(self.name)
# 每次延时0.5s,
time.sleep(0.5)
def main():
# 创建线程对象thread1,然后用start方法启动线程
thread1 = Print_Time()
thread1.start()
# 创建线程对象thread2,传入参数,然后用start方法启动线程
thread2 = Print_Name("张三")
thread2.start()
if __name__ == '__main__':
main()
运行结果:
Thu Jan 20 23:08:40 2022
张三
张三
Thu Jan 20 23:08:41 2022
张三
张三
Thu Jan 20 23:08:42 2022
Thu Jan 20 23:08:43 2022
Thu Jan 20 23:08:44 2022
Thu Jan 20 23:08:45 2022
Thu Jan 20 23:08:47 2022
Thu Jan 20 23:08:48 2022
标签:20,Thread,Python,Jan,threading,线程,time,多线程 来源: https://blog.csdn.net/W_000/article/details/122607042