码迷,mamicode.com
首页 > 编程语言 > 详细

python中的线程

时间:2018-02-10 00:05:27      阅读:150      评论:0      收藏:0      [点我收藏+]

标签:print   started   阻塞   时间   down   get   实例化   enum   守护   

1.线程的创建

1.1 通过thread类直接创建

    import threading
    import time
    
    def foo(n):
        time.sleep(n)
        print("foo func:",n)
    
    def bar(n):
        time.sleep(n)
        print("bar func:",n)
    
    s1=time.time()
    
    #创建一个线程实例t1,foo为这个线程要运行的函数
    t1=threading.Thread(target=foo,args=(3,))
    t1.start()    #启动线程t1
    
    #创建一个线程实例t2,bar为这个线程要运行的函数
    t2=threading.Thread(target=bar,args=(5,))
    t2.start()    #启动线程t2
    
    print("ending")
    
    s2=time.time()
    
    print("cost time:",s2-s1)

在这段程序里,一个函数会先休眠几秒钟,然后再打印一句话,第二个函数也是先休眠几秒钟,然后打印一句话。

接着程序会实例化两个线程,并调用两个函数来执行,最后会打印程序问总共执行了多少时间

程序运行结果如下:

ending
cost time: 0.002000093460083008
foo func: 3
bar func: 5

程序会先运行父线程,打印"ending",然后打印程序执行父线程的时间,最后才会运行子线程

1.2 通过thread类来继承式创建

    import threading
    import time
    
    # 定义MyThread类,其继承自threading.Thread这个父类
    class MyThread(threading.Thread): 
    
        def __init__(self):
            threading.Thread.__init__(self)
    
        def run(self):
            print("ok")
            time.sleep(2)
            print("end t1")
    
    # 对类进行实例化
    t1=MyThread()
    
    # 启动线程
    t1.start()
    print("ending")

2. Thread类的一些常用方法

2.1 join():在子线程完成之前,主线程将一直被阻塞****

线程的join方法必须在子线程的start方法之后定义

在第一个例子中加入两行代码,如下:

    import threading
    import time
    
    
    def foo(n):
        time.sleep(n)
        print("foo func:",n)
    
    def bar(n):
        time.sleep(n)
        print("bar func:",n)
    
    s1=time.time()
    t1=threading.Thread(target=foo,args=(3,))
    t1.start()
    
    t2=threading.Thread(target=bar,args=(5,))
    t2.start()
    
    t1.join()       # 阻塞t1线程
    t2.join()       # 阻塞t2线程
    
    print("ending")
    s2=time.time()
    
    print("cost time:",s2-s1)

再次执行程序,运行结果如下:

foo func: 3
bar func: 5
ending
cost time: 5.002285957336426

程序运行到子线程t1中的foo方法时会睡眠3秒钟,与此同时,子线程t2也在睡眠

等到子线程t1睡眠完成后,开始打印foo函数中的print语句,然后子线程t1执行完成

2秒钟之后,子线程t2睡眠完成,开始打印bar函数中的print语句,然后子线程t2也执行完成。

而在这之前,主线程一直处于阻塞状态。等到子线程执行完成之后主线程才会执行

2.2 setDeamon(True)

setDaemon方法作用是将进程声明为守护线程,必须在`start()`方法调用之前,

如果不设置为守护线程,程序会被无限挂起

在程序执行过程中,执行一个主线程,主线程又创建一个子线程时,主线程和子线程会分别运行。

当主线程运行完成时,会检验子线程是否执行完成,如果子线程执行完成,则主线程会等待子线程完成后再退出。

但是有的时候只要主线程执行完成之后,不管子线程是否执行完成,都和主线程一起退出,这个就需要调用setDeamon方法了。

拿第一个例子来说吧,现在我想让子线程t1和t2随同主线程关闭,代码如下:

    import threading
    import time
    
    def foo(n):
        print("foo start")
        time.sleep(n)
        print("foo end...")
    
    def bar(n):
        print("bar start")
        time.sleep(n)
        print("bar end...")
    
    s1 = time.time()
    t1 = threading.Thread(target=foo, args=(3,))
    t1.setDaemon(True)
    t1.start()
    
    t2 = threading.Thread(target=bar, args=(5,))
    t2.setDaemon(True)
    t2.start()
    
    print("ending")
    s2 = time.time()
    
    print("cost time:", s2 - s1)

程序运行结果如下 :

foo start
bar start
ending
cost time: 0.003000020980834961

可以看到,把t1和t2都声明为守护线程后,程序自上而下执行,先执行子线程t1中的foo方法,打印foo函数中的第一条打印语句,然后子线程t1进入到睡眠状态。

然后子线程t2执行,打印bar函数中的第一条print语句,然后子线程t2进入睡眠状态,程序切换到主线程运行

主线程打印完"ending"语句,发现子线程t1和t2已经被设置为守护线程,所以主线程不需要再等待两个子线程执行完成,而是立即结束,打印整个程序的执行时间。

整个程序就跟随主线程一起关闭了。

2.3 子线程的一些其他方法

isAlive()           #判断一个线程是否是活动线程
getName()           #返回线程的名字
setName()           #设置线程的名字
    import threading
    import time
    
    def foo(n):
        time.sleep(n)
        print("foo func:", n)
    
    def bar(n):
        time.sleep(n)
        print("bar func:", n)
    
    s1 = time.time()
    t1 = threading.Thread(target=foo, args=(3,))
    t1.setDaemon(True)
    
    print("线程还未启动时,判断t1是否是活动的线程:", t1.isAlive())  # 线程还未启动,所以是False
    t1.start()  # 启动线程
    print("线程已启动时,判断t1是否是活动的线程:", t1.isAlive())  # 线程已启动,所以是True
    print("修改前的线程名为:",t1.getName())  # 获取线程名
    t1.setName("t1")        #设置线程名
    print("修改后的线程名为:",t1.getName())  # 获取线程名
    
    t1.join()
    
    print("线程执行完成时,判断t1是不否是活动的线程:", t1.isAlive())  # 线程已执行完成,所以是False
    
    # print(threading.activeCount())
    print("ending")
    s2 = time.time()
    
    print("cost time:", s2 - s1)

程序执行结果:

线程还未启动时,判断t1是否是活动的线程: False
线程已启动时,判断t1是否是活动的线程: True
修改前的线程名为: Thread-1
修改后的线程名为: t1
foo func: 3
线程执行完成时,判断t1是不否是活动的线程: False
ending
cost time: 3.001171588897705

3.threading模块提供的一些方法

threading.currentThread()   #返回当前的线程变量
threading.enumerate()       #返回一个包含正在运行的线程的列表,不包括启动前和终止后的线程
threading.activeCount()     #返回正在运行的线程数量,等同于len(threading.enumerate())
    import threading
    import time

    def foo(n):
        time.sleep(n)
        print("foo func:", n)

    def bar(n):
        time.sleep(n)
        print("bar func:", n)

    s1 = time.time()
    t1 = threading.Thread(target=foo, args=(3,))
    t1.setDaemon(True)
    t1.start()

    t2 = threading.Thread(target=bar, args=(5,))
    t2.setDaemon(True)
    t2.start()

    print("程序中正在运行的线程数量:",threading.activeCount())
    print("程序中当前的线程变量:",threading.currentThread())
    print("当前正在运行的线程的列表:",threading.enumerate())
    print("ending")
    s2 = time.time()

    print("cost time:", s2 - s1)

程序执行结果:

程序中正在运行的线程数量: 3
程序中当前的线程变量: <_MainThread(MainThread, started 7064)>
当前正在运行的线程的列表: [<_MainThread(MainThread, started 7064)>, <Thread(Thread-1, started daemon 6384)>, <Thread(Thread-2, started daemon 2640)>]
ending
cost time: 0.002000093460083008

python中的线程

标签:print   started   阻塞   时间   down   get   实例化   enum   守护   

原文地址:https://www.cnblogs.com/renpingsheng/p/8437027.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!