python多线程实现

simon_chen 发布于2019-07-30 14:49 / 1377人阅读

摘要：中的多线程我参考了中的介绍，介绍的很入门很详细。如只设置了第个和第个，没有设置这只会掉第个子线程个人猜测，当程序运行完主线程后则会检查剩余的子线程，将最后面的且是子进程删掉。第个没有掉是因为线程还在运行并且是默认状态不能被的。

本人初学者开始第一篇博客，记录学习的点点滴滴，以作为备忘录，也希望能同大家一起分享。有理解错误的地方希望大家指正。 python中的多线程我参考了（http://www.cnblogs.com/fnng/p...）中的介绍，介绍的很入门很详细。介绍了threading的基本用法。

最简单的情况是：

import threading
import time
def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep(2)               #子程序等2秒。。
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
print("程序结束，%s:"%(time.ctime()))

#输出为-------------------
我是第1个进程,开始时间是Sun Oct 22 17:45:37 2017
我是第2个进程,开始时间是Sun Oct 22 17:45:37 2017
我是第3个进程,开始时间是Sun Oct 22 17:45:37 2017
我是第4个进程,开始时间是Sun Oct 22 17:45:37 2017
我是第5个进程,开始时间是Sun Oct 22 17:45:37 2017
**程序结束，Sun Oct 22 17:45:37 2017:**          #主线程继续执行，不等待，也不杀死子线程
我是第1个进程,结束时间是Sun Oct 22 17:45:39 2017
我是第2个进程,结束时间是Sun Oct 22 17:45:39 2017
我是第5个进程,结束时间是Sun Oct 22 17:45:39 2017
我是第3个进程,结束时间是Sun Oct 22 17:45:39 2017
我是第4个进程,结束时间是Sun Oct 22 17:45:39 2017

这里介绍另外两个函数:setDaemon()、join()
join：如在一个线程B中调用threada.join()，则threada结束后，线程B才会接着threada.join()往后运行。
setDaemon：主线程A启动了子线程B，调用b.setDaemaon(True)，则主线程结束时，会把子线程B也杀死，与C/C++中得默认效果是一样的。

比如我想让主程序等待子程序完成之后再运行，可以是用t.join()
其中t是指某个子进程，如t1,t2....然后join()可以有一个参数，主进程等待多少秒，如t1.join(2)指在t1子进程开始后，主进程等待2秒就继续执行。

def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep(i*2)               #模拟子进程的运行时间，ID越大时间越长
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
threads[1].join(1)              #主进程在第二个子进程开始后阻塞1秒再运行
print("主进程：，%s:"%(time.ctime()))

#输出---------------------
我是第1个进程,开始时间是Sun Oct 22 18:12:14 2017
我是第1个进程,结束时间是Sun Oct 22 18:12:14 2017
我是第2个进程,开始时间是Sun Oct 22 18:12:14 2017     #第二个子进程14秒开始
我是第3个进程,开始时间是Sun Oct 22 18:12:14 2017
我是第4个进程,开始时间是Sun Oct 22 18:12:14 2017
我是第5个进程,开始时间是Sun Oct 22 18:12:14 2017
主进程：Sun Oct 22 18:12:15 2017:                  #主进程在阻塞一秒后的15秒开始启动运行
我是第2个进程,结束时间是Sun Oct 22 18:12:16 2017
我是第3个进程,结束时间是Sun Oct 22 18:12:18 2017
我是第4个进程,结束时间是Sun Oct 22 18:12:20 2017
我是第5个进程,结束时间是Sun Oct 22 18:12:22 2017

若想等所有的子进程都完成后，主进程在进行可以，简单情况可以用最慢的一个子进程来对主进程进行阻塞，这里最慢的是第5个子进程。可以：threads[4].join()。

import tensorflow as tf
import numpy as np
import random
import threading
import time


def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模拟子程序运行随机秒
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
threads[4].join()
print("主进程：%s:"%(time.ctime()))

#输出-----------------------
我是第1个进程,开始时间是Sun Oct 22 18:29:28 2017
我是第2个进程,开始时间是Sun Oct 22 18:29:28 2017
我是第3个进程,开始时间是Sun Oct 22 18:29:28 2017
我是第4个进程,开始时间是Sun Oct 22 18:29:28 2017
我是第5个进程,开始时间是Sun Oct 22 18:29:28 2017
我是第1个进程,结束时间是Sun Oct 22 18:29:29 2017
我是第2个进程,结束时间是Sun Oct 22 18:29:31 2017
我是第3个进程,结束时间是Sun Oct 22 18:29:33 2017
我是第4个进程,结束时间是Sun Oct 22 18:29:35 2017
我是第5个进程,结束时间是Sun Oct 22 18:29:37 2017
主进程：Sun Oct 22 18:29:37 2017:                      #主进程等到最后一个子进程结束后才运行

另一种情况是，比如我想让主程序运行完就立刻结束，杀死子程序：可以用t.setDaemon(True)

def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模拟子程序运行随机秒
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

for t in threads:
    t.setDaemon(True)
    t.start()
print("主进程：%s:"%(time.ctime()))

#输出---------------------------------
我是第1个进程,开始时间是Sun Oct 22 19:04:06 2017
我是第2个进程,开始时间是Sun Oct 22 19:04:06 2017
我是第3个进程,开始时间是Sun Oct 22 19:04:06 2017
我是第4个进程,开始时间是Sun Oct 22 19:04:06 2017
我是第5个进程,开始时间是Sun Oct 22 19:04:06 2017
主进程：Sun Oct 22 19:04:06 2017:                 #可以看到主线程完成后，后面就没有子线程了。

一种特殊情况请注意：当并非像上面每个子进程一样都设置t.setDaemon(True)（有的设置有的没有。。）
如：

threads[2].setDaemon(True)   #只设置了第3个和第5个，1,2,4没有设置这只会kill掉第5个子线程
                             #个人猜测，当程序运行完主线程后则会检查剩余的子线程，将最后面的                             
threads[4].setDaemon(True)   #且是setDaemon(True) 子进程删掉。第3个没有kill掉是因为4线程还在运行
for t in threads:            #并且4是默认状态不能被kill的。这时主进程依然在等待4完成而不会
    t.start()                #杀掉剩余进程，当4完成了，就不等待了直接杀掉剩余进程

我们可以这样验证，在线程4结束前看看线程5是否存活：

import tensorflow as tf
import numpy as np
import random
import threading
import time


def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模拟子程序运行随机秒
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
    if i ==3:
        print("我是第4个进程：结束前进程5的状态是：" ,threads[4].is_alive())   #加这一句判断现成物
                                                                            #的存活情况
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

#threads[0].setDaemon(True)
#threads[1].setDaemon(True)
threads[2].setDaemon(True)
#threads[3].setDaemon(True)
threads[4].setDaemon(True)

for t in threads:
    t.start()
print("主进程：%s:"%(time.ctime()))

#输出----------------------------------
我是第1个进程,开始时间是Sun Oct 22 19:22:36 2017
我是第2个进程,开始时间是Sun Oct 22 19:22:36 2017
我是第3个进程,开始时间是Sun Oct 22 19:22:36 2017
我是第4个进程,开始时间是Sun Oct 22 19:22:36 2017
我是第5个进程,开始时间是Sun Oct 22 19:22:36 2017
主进程：Sun Oct 22 19:22:36 2017:
我是第1个进程,结束时间是Sun Oct 22 19:22:37 2017
我是第2个进程,结束时间是Sun Oct 22 19:22:39 2017
我是第3个进程,结束时间是Sun Oct 22 19:22:41 2017
我是第4个进程,结束时间是Sun Oct 22 19:22:43 2017
我是第4个进程：结束前进程5的状态是： True        #可以看到，此时线程5还是存活的，但4结束后5就消失了。

最后一种应用时，我们希望主程序等待某几个子线程先执行完后在运行，并且杀死剩余没有完成的程序，可以用setDaemon()、join() 组合的方式：
如：完整运行完第1,2,3线程，之后运行主线程，主线程完成后杀死剩余的子线程：

def fuction(i):
    print("我是第%s个进程,开始时间是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模拟子程序运行随机秒
    print("我是第%s个进程,结束时间是%s"%(i+1,time.ctime()))
    if i ==3:
        print("我是第4个进程：结束前进程5的状态是：" ,threads[4].is_alive())
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

#threads[0].setDaemon(True)
#threads[1].setDaemon(True)
#threads[2].setDaemon(True)
threads[3].setDaemon(True)          #设置第4和5子线程为可以kill的线程
threads[4].setDaemon(True)

for t in threads:
    t.start()
threads[0].join()                  #设置第1,2,3线程阻塞主线程的子线程
threads[1].join()
threads[2].join()
print("主进程：%s:"%(time.ctime()))

#输出--------------------------
我是第1个进程,开始时间是Sun Oct 22 19:32:24 2017
我是第2个进程,开始时间是Sun Oct 22 19:32:24 2017
我是第3个进程,开始时间是Sun Oct 22 19:32:24 2017
我是第4个进程,开始时间是Sun Oct 22 19:32:24 2017
我是第5个进程,开始时间是Sun Oct 22 19:32:24 2017
我是第1个进程,结束时间是Sun Oct 22 19:32:25 2017
我是第2个进程,结束时间是Sun Oct 22 19:32:27 2017
我是第3个进程,结束时间是Sun Oct 22 19:32:29 2017
主进程：Sun Oct 22 19:32:29 2017:                #我们可以看到只完成了第1,2,3线程，然后最后是主线程

这篇文章就到这里，python中子线程的暂停，阻塞，关闭，和唤醒，本人都不是很明确，如有好方法希望大家一起交流。我先写在这里。对于tensorflow中的读取数据线程控制，等我整理在下一篇博客。

GPU云服务器云服务器实现多线程多线程实现 php实现多线程 android实现多线程

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/40938.html

浅谈Python多线程

摘要：进程可创建多个线程来执行同一程序的不同部分。就绪等待线程调度。运行线程正常运行阻塞暂停运行，解除阻塞后进入状态重新等待调度。消亡线程方法执行完毕返回或者异常终止。多线程多的情况下，依次执行各线程的方法，前头一个结束了才能执行后面一个。浅谈Python多线程作者简介: 姓名:黄志成(小黄)博客: 博客线程一.什么是线程? 操作系统原理相关的书，基本都会提到一句很经典的话：进程...

zsirfs 2019-07-30 16:07 评论0 收藏0
Python多线程

摘要：多线程的理解多进程和多线程都可以执行多个任务，线程是进程的一部分。多线程创建在中，同样可以实现多线程，有两个标准模块和，不过我们主要使用更高级的模块。多线程的应用场景。 1、多线程的理解多进程和多线程都可以执行多个任务，线程是进程的一部分。线程的特点是线程之间可以共享内存和变量，资源消耗少（不过在Unix环境中，多进程和多线程资源调度消耗差距不明显，Unix调度较快），缺点是线程之间...

dcr309duan 2019-07-30 15:05 评论0 收藏0
python大佬养成计划----进程、线程与多进程

摘要：在一个进程内部，要同时干多件事，就需要同时运行多个子任务，我们把进程内的这些子任务称为线程。总结一下，多任务的实现方式有三种多进程模式多线程模式多进程多线程模式线程是最小的执行单元，而进程由至少一个线程组成。进程与线程很多同学都听说过，现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持多任务的操作系统。什么叫多任务呢？简单地说，就是操作系统可以同时...

taowen 2019-07-30 17:49 评论0 收藏0
python学习笔记- 多线程

摘要：也提供多线程支持，而且中的线程并非是模拟出来的多线程，而是系统级别的标准库提供了两个模块和。同一个变量，线程则会互相共享。例如多个线程对银行中的某一个账户进行操作。但是实际情况是随意切换线程。说到的多线程编程，就会绕不过。该文章参考了http://www.liaoxuefeng.com/wi... 廖雪峰的教程。一个进程至少有一个线程。Python也提供多线程支持，而且Python...

RiverLi 2019-07-25 11:23 评论0 收藏0
Python协程（真才实学，想学的进来）

摘要：所以与多线程相比，线程的数量越多，协程性能的优势越明显。值得一提的是，在此过程中，只有一个线程在执行，因此这与多线程的概念是不一样的。真正有知识的人的成长过程，就像麦穗的成长过程：麦穗空的时候，麦子长得很快，麦穗骄傲地高高昂起，但是，麦穗成熟饱满时，它们开始谦虚，垂下麦芒。 ——蒙田《蒙田随笔全集》上篇论述了关于python多线程是否是鸡肋的问题，得到了一些网友的认可，当然也有...

lykops 2019-07-30 16:55 评论0 收藏0
通过网络图片小爬虫对比Python中单线程与多线（进）程的效率

摘要：批评的人通常都会说的多线程编程太困难了，众所周知的全局解释器锁，或称使得多个线程的代码无法同时运行。多线程起步首先让我们来创建一个名为的模块。多进程可能比多线程更易使用，但需要消耗更大的内存。批评 Python 的人通常都会说 Python 的多线程编程太困难了，众所周知的全局解释器锁（Global Interpreter Lock，或称 GIL）使得多个线程的 Python 代码无...

W4n9Hu1 2019-07-31 12:22 评论0 收藏0