Python 多线程 线程安全、daemon简介 (四)

 

 

线程安全

只能在Winodws下的ipython中演示,Python命令行、Pycharm、Mac下的ipython都演示不出效果

import threading

def worker():
    for _ in range(100):
        print("{} is running.".format(threading.current_thread().name))

for i in range(1,5):
    name = "worker-{}".format(i)
    t = threading.Thread(target=worker,name=name)
    t.start()

  这里只展示在Windows下ipython中的运行结果:

  对比代码,输出应该是一行一行打印,但是在ipython中有个别行打印时连在了一起。

print属于线程内的语句,且print函数动作分两部分,打印字符串和打印换行,该线程print拼接换行之前被其它线程打断了,这说明print函数是线程不安全的。

 

简单理解,线程不安全就是正在做某事,被打断了。

 

线程安全的解决方法:

1、拼接字符串

print("{} is running\n".format(threading.current_thread()),end="")

  在print打印字符串时就打印'\n'换行符,因为字符串是不可变类型,它可以作为一个整体不被分割输出。

2、logging模块

logging模块是分级别输出,不允许被打断,是安全的。

import threading
import time
import logging
logging.basicConfig(level=logging.INFO) #警告级别

def worker():
    for x in range(100):
        # time.sleep(0.5)
        msg = ("{} is running".format(threading.current_thread()))
        logging.info(msg)

for i in range(1):
    t = threading.Thread(target=worker,name='worker-{}'.format(i))
    t.start()

运行结果:
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
INFO:root:<Thread(worker-0, started 123145503371264)> is running
......

  关于logging模块下一篇详细介绍。

 

daemon线程与non-daemon线程:

进程靠线程执行代码,一个进程至少有一个主线程,其它线程都是工作线程。

主线程是第一个启动的线程。

父线程:如果线程A启动了一个线程B,A就是B的父线程。

子线程:B就是A的子线程。

 

daemon属性要在start()方法之前设置。

daemon=None 或者不设置时,  等同于父线程的daemon的值

daemon=True   父线程退出该线程也退出

daemon=False  父线程必须等该线程执行完毕。

 

class Thread:
	def __init__(self, group=None, target=None, name=None,
	                 args=(), kwargs=None, *, daemon=None):

	  if daemon is not None:
	      self._daemonic = daemon
          else:
              self._daemonic = current_thread().daemon #默认False

  Python在构造线程时,daemon参数接收值为True或False,默认为None时,等同于父线程的daemon值。

举例:

import threading
import time
import logging
logging.basicConfig(level=logging.INFO) #警告级别

def worker():
    for x in range(100):
        time.sleep(1)
        msg = ("{} is running".format(threading.current_thread()))
        logging.info(msg)

t = threading.Thread(target=worker,name='worker-{}'.format(0),daemon=True)
t.start()

time.sleep(3)
print('ending')

运行结果:
INFO:root:<Thread(worker-0, started daemon 123145520332800)> is running
INFO:root:<Thread(worker-0, started daemon 123145520332800)> is running
ending

  daemon属性为True时,主线程在启动子线程后,继续执行之后语句,主线程执行完毕后,自动退出了所有子线程,主线程也退出。也就是说,当daemon为True时,主线程结束时,子线程无论是否有任务未完成都会随着主线程一起退出。

  当daemon为False时也叫non-daemon,主线程运行完毕后,如果有子线程没有退出,就会等待子线程执行完毕,才会退出主线程,整个程序也就结束了。

 

嵌套的daemon线程:

import threading
import logging
logging.basicConfig(level=logging.INFO) #警告级别
import time

def worker():
    for x in range(10):
        time.sleep(0.3)
        msg = ("{} {} is running".format(x,threading.current_thread()))
        logging.info(msg) #worker不等worker1
        t = threading.Thread(target=worker1,name="worker1-{}".format(x),daemon=True)
        t.start()
        print(x,'~~~~~~~~~~~~~~~~~~~~~')
        # t.join()

def worker1():
    for x in range(1000):
        time.sleep(0.3)
        msg = ("¥¥¥¥¥{} is running".format(threading.current_thread()))
        logging.info(msg)

t = threading.Thread(target=worker,name='worker-{}'.format(0),daemon=False) #主线程等待worker
t.start()             #  主     子    孙
# t.join()            # False False True
time.sleep(1)
print('ending')
print(threading.enumerate())

  这里很容易绕晕,直接看结论把。

 

小结:

主线程    子线程    子子线程

False      False      True

 

主线程

         启动子线程

                     子进程也启动子线程

  

再傻瓜点理解就是层次最深的线程的daemon影响整个程序的执行结果,如果没有设置daemon,则取它的父线程的daemon。 下一篇详细介绍。

 

 

 

 

 

 

小结:

non-daemon (False) 主线程会等待非daemon线程执行完毕才退出,所以工作完整性请使用non-daemon线程。

daemon (True) 主线程结束,子线程也会结束。适用于不关心什么时候启动,什么时候结束,丢失一部分数据也不关心的场景。例如:服务、心跳包、监控场景应用居多。

 

join()方法:

正常场景,主线程在起了一个新的子线程后,主线程和子线程是并行的,互不干扰。但是,假如主线程调用了join方法,那它就得等待子线程完全执行完毕才能执行join()之后的语句,相当于又变成了单线程按顺序执行。

 

举例:

import threading
import time

def worker():
    for i in range(5):
        time.sleep(0.5)
        print('working....')

t = threading.Thread(target=worker)
t.start()
# t.join()  #没有使用join()时的运行情况
print('ending.')

运行结果:
ending.
working....
working....
working....
working....
working....

  上面例子中,先打印了主线程的“ending.”语句,说明没有使用join()方法时,主线程线运行完毕,等待子线程也运行完毕才退出程序。

import threading
import time

def worker():
    for i in range(5):
        time.sleep(0.5)
        print('working....')

t = threading.Thread(target=worker)
t.start()
t.join()   #使用join()方法时
print('ending.')

运行结果:
working....
working....
working....
working....
working....
ending.

  上面例子中,程序先打印的是子线程的语句,子线程运行完毕后,才打印了主线程的“ending.”语句,也就是使用了join()方法后,又变成了面向过程的程序,后一个语句必须要等前一个语句执行完毕才能执行。

 

 

 

 

  

 

posted @ 2017-12-15 17:08  ihoneysec  阅读(1439)  评论(0编辑  收藏  举报