Python程序暂停

将进程挂起(Suspend) 而非 阻塞(Block)
如果用sleep() 进程将阻塞
假设进程下有两个线程 那么这两个线程会继续运行
要使进程挂起 可以考虑使用psutil

import psutil
p = psutil.Process(pid)
p.suspend()   #挂起进程
p.resume()    #恢复进程

 

为了证明效果 我写了一个简单的进程Process
其下有两个线程 读者Reader 和 写者Writer（简单的读者写者问题）

Process:

import threading

from time import ctime, sleep
import ThreadInReadAndWriteProblem
import multiprocessing
import  os

class Process(multiprocessing.Process):    


    def __init__(self):
        multiprocessing.Process.__init__(self)  #手动实现父类
        pid = os.getpid()

    def run(self):
        print '当前运行进程PID :  %s  '  %self.pid   #子线程的id与父进程的pid相同 属于 同一个进程

        for i in range(0,5):
            r = ThreadInReadAndWriteProblem.Reader()
            w = ThreadInReadAndWriteProblem.Writer()
            w.start()
            r.start()



	print '进程阻塞'
        sleep(10)   #总共运行时间10秒

Reader&Writer

import threading
from time import ctime, sleep
import  os

mutex = threading.Lock()    #互斥锁 
mutex_readercount = threading.Lock() #计数时的互斥 计算当前正在读的数目
readerCount = 0 number = 0

#不满足条件的 进入阻塞状态


class Reader(threading.Thread):       #读者
    def __init__(self):
        threading.Thread.__init__(self) #继承父类构造函数

    def run(self):
        global mutex
        global readerCount
        #print '线程PID:  %s ' %os.getpid()
        while True:
              mutex_readercount.acquire()
              readerCount +=1
              if readerCount == 1:
                 print '读者进程等待中，编号%s' %(self.name)
                 mutex.acquire() == False     # 第一个需要申请


              mutex_readercount.release()
              print '开始读 , 读者编号 %s ,现在时间是 %s' %(self.name,ctime())
              sleep(2)
              print '完成读 , 读者编号 %s , 现在时间是 %s' %(self.name,ctime())

              mutex_readercount.acquire()
              readerCount -= 1
              if readerCount == 0:   #所有读者均完成
                    print '最后一个读者完成读 '
                    mutex.release()
              mutex_readercount.release()




class Writer(threading.Thread):      #写者
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        global mutex
        global writerCount
        #print '线程PID： %s'  %os.getpid()
        while True:
            print '写者进程等待中 编号： %s' %(self.name)
            mutex.acquire()              
            print '开始写  编号：%s  现在时间是： %s ' %(self.name,ctime())
            sleep(5)
            print '结束写  编号: %s  现在时间是 %s' %(self.name,ctime())
            mutex.release()

测试程序

import ThreadInReadAndWriteProblem
import SingleProcessSchedulerMultiprocess
import psutil
import Scheduler
from time import ctime, sleep

def main():
    p = SingleProcessSchedulerMultiprocess.Process()
    p.start()

    sleep(3)



    stop(p.pid)
    print '进程挂起 %s' %ctime()
    sleep(5)

    wake(p.pid)
    print '唤醒进程 %s' %ctime()



def stop(pid):
        print '进程暂停  进程编号 %s ' %(pid)
        p = psutil.Process(pid)
        p.suspend()

def wake(pid):
        print '进程恢复  进程编号 %s ' %(pid)
        p = psutil.Process(pid)
        p.resume()



if __name__ == '__main__':
   main()

结果：

当前运行进程PID :  3096  
写者进程等待中 编号： Thread-2
开始写  编号：Thread-2  现在时间是： Mon Nov 30 21:12:12 2015 
读者进程等待中，编号Thread-1
写者进程等待中 编号： Thread-4
进程阻塞
写者进程等待中 编号： Thread-6
写者进程等待中 编号： Thread-8
写者进程等待中 编号： Thread-10
进程暂停  进程编号 3096 
进程挂起 Mon Nov 30 21:12:15 2015
进程恢复  进程编号 3096 
唤醒进程 Mon Nov 30 21:12:20 2015
结束写  编号: Thread-2  现在时间是 Mon Nov 30 21:12:20 2015
写者进程等待中 编号： Thread-2
开始读 , 读者编号 Thread-1 ,现在时间是 Mon Nov 30 21:12:20 2015

开始读 , 读者编号 Thread-3 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-5 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-7 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-9 ,现在时间是 Mon Nov 30 21:12:20 2015
完成读 , 读者编号 Thread-1 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-3 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-5 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-7 , 现在时间是 Mon Nov 30 21:12:22 2015