smpl_signal_multiproc_multithread.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
    複数プロセスから複数スレッドを起動して、Ctrl-Cで停止する例

'''

import time
import threading
import multiprocessing
import logging

formatter=logging.Formatter('%(asctime)s %(levelname)5s %(processName)-12s %(threadName)-10s %(message)s')
logger = multiprocessing.log_to_stderr()
for handler in logger.handlers:
    handler.setFormatter(formatter)
logger.setLevel(logging.DEBUG)

class WorkerThread(threading.Thread):
    def __init__(self,done_flag):
        self.done_flag=done_flag
        threading.Thread.__init__(self)

    def run(self):
        while True:
            try:
                time.sleep(1)
                if self.done_flag.value:
                    logger.debug('Done')
                    break
            except (KeyboardInterrupt,SystemExit),e:
                break
        logger.debug('exitting thread')
        return

class WorkerProc(multiprocessing.Process):
    def run(self):
        done_flag=multiprocessing.Value('b', False)
        self.threads=[]
        for i in range(2):
            self.threads.append(WorkerThread(done_flag))
        for t in self.threads:
            t.start()
        while True:
            try:
                time.sleep(60)
            except KeyboardInterrupt,e:
                logger.info("Cought keyboard interrupt by WorkerProc")
                done_flag.value=True
                while True:
                    if t.isAlive():
                        time.sleep(1)
                    else:
                        break
                break
            t.join()
        return


def main():

    procs=[]
    for i in range(2):
        procs.append(WorkerProc())
    for p in procs:
        p.start()


    while True:
        try:
            time.sleep(60)
        except KeyboardInterrupt,e:
            logger.info("Cought keyboard interrupt by main")
            break

    for p in procs:
        p.join()

if __name__ == '__main__':
    main()

smpl_signal_multiprocess.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
    複数プロセスを起動して、Ctrl-Cで、どちらのプロセスがシグナルをうけとるか確認

'''

import time
import multiprocessing
import logging

logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)

class WorkerProc(multiprocessing.Process):
    def run(self):
        while True:
            try:
                time.sleep(60)
            except KeyboardInterrupt,e:
                logger.info("Cought keyboard interrupt by WorkerProc")
                break
        return


def main():
    procs=[]
    for i in range(3):
        procs.append(WorkerProc())
    for p in procs:
        p.start()

    while True:
        try:
            time.sleep(60)
        except KeyboardInterrupt,e:
            logger.info("Cought keyboard interrupt by main")
            break

    for p in procs:
        p.join()

if __name__ == '__main__':
    main()

smpl_signal_multithread.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
    シグナルハンドラを作って複数スレッドを立ち上げた場合
    join中はシグナルを受け付けないので、生死を判断するループを使う
'''
import sys
import time
import threading
import logging
import signal
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s (%(threadName)-10s) %(message)s')

def sighandler(event, signr, handler):
    logging.debug('Caught by sighandler')
    event.set()

class WorkerThread(threading.Thread):
    def __init__(self,t_ev,i):
        self.t_ev=t_ev
        self.i=i
        threading.Thread.__init__(self)

    def run(self):
        while not self.t_ev.isSet():
            time.sleep(2)
            logging.debug('retry')
        logging.debug('exitting thread-{0}'.format(self.i))
        return 0


def main():
    t_ev = threading.Event()
    signal.signal(signal.SIGINT, (lambda a, b: sighandler(t_ev, a, b)))
    ts=[]
    for i in range(5):
        ts.append(WorkerThread(t_ev,i))
    for t in ts:
        t.setDaemon(True)
        t.start()
    all_dead=False
    while not all_dead:
        time.sleep(1)
        logging.debug('Initialize set all_dead=True')
        all_dead=True
        for t in ts:
            if t.isAlive():
                logging.debug('a live thread was found, set all_dead=False')
                all_dead=False
                break
    logging.debug('waiting for threads joining')
    for t in ts:
        logging.debug('joined thread-{0}'.format(t.i))
        t.join()
    return 0

if __name__ == '__main__':
    sys.exit(main())

smpl_signal_onethread.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
    一個のスレッドを起動して、Ctrl-Cで、どちらのスレッドがシグナルをうけとるか確認

'''
import os
import time
import datetime
import threading
import multiprocessing
import logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s (%(threadName)-2s) %(message)s')

class WorkerThread(threading.Thread):
    def __init__(self,done_flag):
        self.done_flag=done_flag
        threading.Thread.__init__(self)

    def run(self):
        while True:
            try:
                time.sleep(1)
                if self.done_flag.value:
                    logging.debug('Done!')
                    break
            except KeyboardInterrupt,e:
                logging.debug('Caught by the thread')
                break
            except SystemExit,e:
                logging.debug('SystemExit')
                break
        logging.debug('exit_thread1')
        return


def main():
    done_flag = multiprocessing.Value('b', False)

    t=WorkerThread(done_flag)

    # Start threads
    t.start()

    # Wait until KeyboardInterrupt
    while True:
        try:
            time.sleep(60)
        except KeyboardInterrupt,e:
            logging.debug('Caught by main')
            done_flag.value=True
            while True:
                if t.isAlive():
                    time.sleep(1)
                else:
                    break
            break
    t.join()

if __name__ == '__main__':
    main()