"""

Author: Allen B. Downey

This file contains an example program from The Little Book of
Semaphores, available from Green Tea Press, greenteapress.com
This code is in the public domain.
"""

import threading, time, os, signal, sys

class Thread(threading.Thread):
"""Wrapper for the Thread class in the threading module."""
def __init__(self, target, *args):
"""Create and start a thread.
target: callable
args: passed along to target
"""
threading.Thread.__init__(self, target=target, args=args)
self.start()

class Semaphore(threading._Semaphore):
"""Wrapper for the Semaphore class in the threading module."""
wait = threading._Semaphore.acquire
def signal(self, n=1):
"""Signal the semaphore.
n: how many times to signal
"""
for i in range(n):
self.release()
def value(self):
"""Returns the current value of the semaphore.
Note: asking for the value of a semaphore is almost always
a bad idea. If you do anything based on the result, it is
likely to be a mistake.
"""
return self._Semaphore__value

def watcher():
"""Forks a process, and the child process returns.
The parent process waits for a KeyBoard interrupt, kills
the child, and exits.
This is a workaround for a problem with Python threads:
when there is more than one thread, a KeyBoard interrupt
might be delivered to any of them (or occasionally, it seems,
none of them).
"""
child = os.fork()
if child == 0:
 return
try:
os.wait()
except KeyboardInterrupt:
print 'KeyBoardInterrupt'
try:
os.kill(child, signal.SIGKILL)
except OSError:
pass
sys.exit()