python多线程实现kmeans_python多线程实现

本人初学者开始第一篇博客，记录学习的点点滴滴，以作为备忘录，也希望能同大家一起分享。有理解错误的地方希望大家指正。 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中的读取数据线程控制，等我整理在下一篇博客。