[Python]多线程入门

原文:http://blog.csdn.net/ice110956/article/details/28421807

Python的多线程有两种实现方法:

函数,线程类

1.函数

调用thread模块中的start_new_thread()函数来创建线程,以线程函数的形式告诉线程该做什么

  1. # -*- coding: utf-8 -*-
  2. import thread
  3. def f(name):
  4. #定义线程函数
  5. print "this is " + name
  6. if __name__ == '__main__':
  7. thread.start_new_thread(f, ("thread1",))
  8. #用start_new_thread()调用线程函数和其他参数
  9. while 1:
  10. pass

不过这种方法暂时没能找到其他辅助方法,连主线程等待都要用while 1这种方法解决。

2.线程类

调用threading模块,创建threading.Thread的子类来得到自定义线程类。

  1. # -*- coding: utf-8 -*-
  2. import threading
  3. class Th(threading.Thread):
  4. def __init__(self, name):
  5. threading.Thread.__init__(self)
  6. self.t_name = name
  7. #调用父类构造函数
  8. def run(self):
  9. #重写run()函数,线程默认从此函数开始执行
  10. print "This is " + self.t_name
  11. if __name__ == '__main__':
  12. thread1 = Th("Thread_1")
  13. thread1.start()
  14. #start()函数启动线程,自动执行run()函数

threading.Thread类的可继承函数:

getName() 获得线程对象名称

setName() 设置线程对象名称

join() 等待调用的线程结束后再运行之后的命令

setDaemon(bool) 阻塞模式,True:父线程不等待子线程结束,False 等待,默认为False

isDaemon() 判断子线程是否和父线程一起结束,即setDaemon()设置的值

isAlive() 判断线程是否在运行

实例

  1. import threading
  2. import time
  3. class Th(threading.Thread):
  4. def __init__(self, thread_name):
  5. threading.Thread.__init__(self)
  6. self.setName(thread_name)
  7. def run(self):
  8. print "This is thread " + self.getName()
  9. for i in range(5):
  10. time.sleep(1)
  11. print str(i)
  12. print self.getName() + "is over"

join()阻塞等待

  1. if __name__ == '__main__':
  2. thread1 = Th("T1 ")
  3. thread1.start()
  4. #thread1.join()
  5. print "main thread is over"

不带thread1.join(),得到如下结果:

This is thread T1

main thread is over

0

1

2

T1 is over

不等待thread1完成,执行之后语句。

加了thread1.join(),得到如下结果:

This is thread T1

0

1

2

T1 is over

main thread is over

阻塞等待thread1结束,才执行下面语句

主线程等待

  1. if __name__ == '__main__':
  2. thread1 = Th("T1 ")
  3. thread1.setDaemon(True)
  4. #要在线程执行之前就设置这个量
  5. thread1.start()
  6. print "main thread is over"

报错:Exception in thread T1  (most likely raised during interpreter shutdown):

也就是主线程不等待子线程就结束了。

多个子线程

  1. if __name__ == '__main__':
  2. for i in range(3):
  3. t = Th(str(i))
  4. t.start()
  5. print "main thread is over"

这里的t可同时处理多个线程,即t为线程句柄,重新赋值不影响线程。

这里奇怪的是,运行t.run()时,不会再执行其他线程。虽不明,还是用start()吧。暂且理解为start()是非阻塞并行的,而run是阻塞的。

线程锁

threading提供线程锁,可以实现线程同步。

  1. import threading
  2. import time
  3. class Th(threading.Thread):
  4. def __init__(self, thread_name):
  5. threading.Thread.__init__(self)
  6. self.setName(thread_name)
  7. def run(self):
  8. threadLock.acquire()
  9. #获得锁之后再运行
  10. print "This is thread " + self.getName()
  11. for i in range(3):
  12. time.sleep(1)
  13. print str(i)
  14. print self.getName() + " is over"
  15. threadLock.release()
  16. #释放锁
  17. if __name__ == '__main__':
  18. threadLock = threading.Lock()
  19. #设置全局锁
  20. thread1 = Th('Thread_1')
  21. thread2 = Th('Thread_2')
  22. thread1.start()
  23. thread2.start()

得到结果:

This is thread Thread_1

0

1

2

Thread_1 is over

This is thread Thread_2

0

1

2

Thread_2 is over

 
 
上一篇:docker学习------swarm集群虚机异常关机,node状态为down


下一篇:Android杂谈--Activity、Window、View的关系