利用python多线程和队列管理shell程序

首先来描述下环境，在机器上有不少个JAVA程序，咱们在每一个JAVA程序里都配置了一个启动|中止|重启的脚本

举个例子：

咱们如今要同时运行这些脚本，来达到快速启动全部的JAVA程序，若是咱们只用多线程的话，线程是不会返回消息给父进程，咱们如何才能知道这些程序是启动成功了呢？

因此咱们用到了队列来管理。

"""我试过gevent,可是会在command这里形成阻塞"""

gevent代码以下  若是有朋友知道如何优化，请您告诉我

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-
import os,sys
from datetime import datetime
import commands
import gevent.monkey
gevent.monkey.patch_os()
import gevent

def Servers():
    servers=commands.getoutput('''ls /data/program/payment/ | grep 'payment' ''')
    servers=servers.split('\n')
    return servers

def handle(servername):
    if sys.argv[1] == 'start' or sys.argv[1] == 'stop' or sys.argv[1] == 'restart':
        print '\033[1;31;40m'
        print '========================>>>go to handle %s<<<=========================' %servername
        print '\033[0m'
        r=commands.getoutput('''su - tomcat -c "/data/program/payment/%s/bin/server.sh %s &"  ''' %(servername,sys.argv[1]))   #在这里会阻塞，咱们没法找到合适的地方进行协程的切换
        gevent.sleep(0)                #不管放到何处，不是以前就是切换以后都会阻塞。
        print r
    else:
        print 'Please Use start | stop | restart To Handle The Command'
        sys.exit(1)
    
if __name__ == '__main__':
    s=Servers()
    threads=[]
    for i in s:
        threads.append(gevent.spawn(handle,i))
#    print threads
    gevent.joinall(threads)

多线程代码以下

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-

from datetime import datetime
import commands
from Queue import Queue
from threading import Thread

_sentinel = object()

def Servers():
    servers=commands.getoutput('''ls /data/program/payment/ | grep 'payment' ''')
    servers=servers.split('\n')
    return servers

def producer(servername,out_q):
    if sys.argv[1] == 'start' or sys.argv[1] == 'stop' or sys.argv[1] == 'restart':
        print '\033[1;31;40m'
        print 'put %s in Queue' %servername.center(20,'*')
        print '\033[0m'
        out_q.put_nowait(commands.getoutput('''su - tomcat -c "/data/program/payment/%s/bin/server.sh %s &"  ''' %(servername,sys.argv[1])))   #放入队列的对象
        
    else:
        print 'Please Use start | stop | restart To Handle The Command'
        sys.exit(1)

def consumer(servername,in_q):
    n=len(servername)
    L=[]                                  #增长一个已完成的程序列表
    while n > 0:                          #循环在队列中取结果，直到循环结束
        data=in_q.get()
        n -= 1
        data1 = commands.getoutput(''' echo " %s " | egrep "Starting|Stopping" |awk 'NR==1{print $3}'  ''' %data)         #格式化字符串data，得出已经执行的程序名称
        L.append(data1)
        print "\n%s 已经被处理\n" %L
        print '\033[1;31;40m'
        print data
        print '\n%s 未处理完成,若是长时间未完成,请查看日志\n' %list(set(servername).difference(set(L)))                #这里取原始列表和已经完成的列表差集，得出哪些程序还未执行完成。
        print '\033[0m'
    print '\033[1;31;40m'
    print '全部工做已经完成!!!!!!!'
    print '\033[0m' 

if __name__ == '__main__':
    s=Servers()
    q = Queue()
    t1 = Thread(target=consumer, args=(s,q,))           #消费者在队列中获取结果，前面的函数内部已经循环获取
    for i in s:
        t2=Thread(target=producer, args=(i,q,))         #讲线程进行管理，放入队列
        t2.start()                                      #启动生产者线程
#        t2.join()                                      #启动生产者之后放弃校验线程是否结束，进行并发，由于咱们是把线程放入队列进行管理的，因此不用在这里等待线程结束，若是使用了join这里会阻塞咱们的程序。线程结束后，消费者会通知父进程线程已经结束。
    t1.start()                                          #启动消费者线程
    t1.join()                                           #在获取完成以前进行线程的阻塞

简单的说下join这个方法：

调用Thread.join将会使主调线程堵塞，直到被调用线程运行结束或超时。参数timeout是一个数值类型，表示超时时间，若是未提供该参数，那么主调线程将一直堵塞到被调线程结束。