大橙子网站建设,新征程启航
为企业提供网站建设、域名注册、服务器等服务
【Python】线程的创建、执行、互斥、同步、销毁
网站建设哪家好,找成都创新互联!专注于网页设计、网站建设、微信开发、小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了宝兴免费建站欢迎大家使用!
还是《【Java】利用synchronized(this)完成线程的临界区》(点击打开链接)、《【Linux】线程互斥》(点击打开链接)、《【C++】Windows线程的创建、执行、互斥、同步、销毁》(点击打开链接)中的设置多个线程对一个ticket进行自减操作,用来说明Python中多线程的运用,涉及的创建、执行、互斥、同步、销毁问题。
运行结果如下,还是差不多,运行三次,每次的运行结果,每个线程最终的得票结果是不同的,但是4个线程最终“得票”的总和为 ticket 最初设置的值为100000,证明这4个线程成功实现了互斥。
虽然每次运行结果是不同,但是可以看得出每次运行结果大抵上是平均的。貌似Python对线程作系统资源的处理,比Java要好。
然而,Python总要实现多线程,代码并不像想象中简单,具体如下:
[python] view plain copy print?在CODE上查看代码片派生到我的代码片
# -*-coding:utf-8-*-
import threading;
mutex_lock = threading.RLock(); # 互斥锁的声明
ticket = 100000; # 总票数
# 用于统计各个线程的得票数
ticket_for_thread1 = 0;
ticket_for_thread2 = 0;
ticket_for_thread3 = 0;
ticket_for_thread4 = 0;
class myThread(threading.Thread): # 线程处理函数
def __init__(self, name):
threading.Thread.__init__(self); # 线程类必须的初始化
self.thread_name = name; # 将传递过来的name构造到类中的name
def run(self):
# 声明在类中使用全局变量
global mutex_lock;
global ticket;
global ticket_for_thread1;
global ticket_for_thread2;
global ticket_for_thread3;
global ticket_for_thread4;
while 1:
mutex_lock.acquire(); # 临界区开始,互斥的开始
# 仅能有一个线程↓↓↓↓↓↓↓↓↓↓↓↓
if ticket 0:
ticket -= 1;
# 统计哪到线程拿到票
print "%s抢到了票!票还剩余:%d。" % (self.thread_name, ticket);
if self.thread_name == "线程1":
ticket_for_thread1 += 1;
elif self.thread_name == "线程2":
ticket_for_thread2 += 1;
elif self.thread_name == "线程3":
ticket_for_thread3 += 1;
elif self.thread_name == "线程4":
ticket_for_thread4 += 1;
else:
break;
# 仅能有一个线程↑↑↑↑↑↑↑↑↑↑↑↑
mutex_lock.release(); # 临界区结束,互斥的结束
mutex_lock.release(); # python在线程死亡的时候,不会清理已存在在线程函数的互斥锁,必须程序猿自己主动清理
print "%s被销毁了!" % (self.thread_name);
# 初始化线程
thread1 = myThread("线程1");
thread2 = myThread("线程2");
thread3 = myThread("线程3");
thread4 = myThread("线程4");
# 开启线程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
# 等到线程1、2、3、4结束才进行以下的代码(同步)
thread1.join();
thread2.join();
thread3.join();
thread4.join();
print "票都抢光了,大家都散了吧!";
print "=========得票统计=========";
print "线程1:%d张" % (ticket_for_thread1);
print "线程2:%d张" % (ticket_for_thread2);
print "线程3:%d张" % (ticket_for_thread3);
print "线程4:%d张" % (ticket_for_thread4);
1、从上面的代码可以看出,在Python2.7中要使用线程必须使用threading而不是古老的thread模块。
如果你像网上部分遗留依旧的文章一样,在Python2.7中使用thread来实现线程,至少在Eclipse的Pydev中会报错:sys.excepthook is missing,lost sys.stderr如下图所示:
所以必须使用现时Python建议使用的threading。
2、与其它编程语言类似,声明一个互斥锁,与一系列的得票数。之后,与Java同样地,Python实现线程的函数,是要重写一个类。而类中使用全局变量,则与同为脚本语言的PHP一样《【php】global的使用与php的全局变量》(点击打开链接),要用global才能使用这个全局变量,而不是C/C++可以直接使用。
3、需要注意的,Python需要在线程跑完class myThread(threading.Thread)这个类的def run(self)方法之前,必须自己手动清理互斥锁,它不会像其它编程语言那样,说线程跑完def run(self)方法,会自然而然地清理该线程被创建的互斥锁。如果没有最后一句手动清理互斥锁,则会造成死锁。
4、最后与其它编程语言一样了,利用线程的join方法可以等待这个线程跑完def run(self)方法中的所有代码,才执行之后的代码,实现同步。否则主函数中的代码,相当于与父线程。主函数开启的线程,相当于其子线程,互不影响的。
Python用sleep停止一个线程的运行,而不影响主线程的运行,案例代码如下:
from threading import *
import time
class MyThread(Thread):
def run (self):
self.ifdo = True;
while self.ifdo:
print 'I am running...'
time.sleep(2)
def stop (self):
print 'I am stopping it...'
self.ifdo = False;
tr = MyThread()
tr.setDaemon(True)
tr.start()
print 'I will stop it...'
time.sleep(5)
tr.stop()
tr.join()
import time
import thread
LOCK = True
def timer(no, interval):
while LOCK:
print 'y'
def test():
thread.start_new_thread(timer, (1, 1))
time.sleep(5)
global LOCK
LOCK = False
time.sleep(5)
if __name__ == '__main__':
test()
可以使用全局变量的,因为线程是共用上下文变量的。
如果解决了您的问题请采纳!
如果未解决请继续追问
这几天在实践的时候,有一个问题一直在困扰我,比如timer,定时器,Python没有这么好的机制,需要自己实现。这个网上也是有一些。但是我自己的需求可能并不一样。
需求:
我需要一个函数工作,比如远程连接一个端口,远程读取文件等,但是我给的时间有限,比如,4秒钟如果你还没有读取完成或者连接成功,我就不等了,很可能对方已经宕机或者拒绝了。这样可以批量做一些事情而不需要一直等,浪费时间。
定时器是最好的,我觉得这个需求,一旦定时过了,就将这个读取函数直接kill。但是这出现了问题。
第一,怎么定时?
第二,时间到了,怎么kill函数
第三,定时函数和kill函数怎么判断该kill了。
写一个多线程,一个线程专门用来计时间,一个用来执行函数,一旦时间到了,就杀死执行函数的线程。我在多线程,python很弱,似乎没有这样的比较简单的一个接口就调用的。不像windows编程。那么,该怎办?
结合我的需求,我这么做:
1、在主进程执行,调用一个进程执行函数,然后主进程sleep,等时间到了,就kill 执行函数的进程。
测试一个例子:
[python] view plain copy
import time
import threading
def p(i):
print i
class task(threading.Thread):
def __init__(self,fun,i):
threading.Thread.__init__(self)
self.fun = fun
self.i = i
self.thread_stop = False
def run(self):
while not self.thread_stop:
self.fun(self.i)
def stop(self):
self.thread_stop = True
def test():
thread1 = task(p,2)
thread1.start()
time.sleep(4)
thread1.stop()
主线程捕获kill的信号以后去终止其他线程, 等其他线程完成以后, 再在主线程中退出.
不过更现代的实现并发的方法是使用异步, 而不是多线程.