import multiprocessing
import time

def worker_1(interval):
    n = 5
    while n > 0:
        # print('The time is {0}'.format(time.ctime()))
        print 'start worker_1'
        time.sleep(interval)
        n -= 1
        print 'end worker_1'

def worker_2(interval):
    n = 5
    while n > 0:
        # print('The time is {0}'.format(time.ctime()))
        print 'start worker_2'
        time.sleep(interval)
        n -= 1
        print 'end worker_2'

def worker_3(interval):
    n = 5
    while n > 0:
        # print('The time is {0}'.format(time.ctime()))
        print 'start worker_3'
        time.sleep(interval)
        n -= 1
        print 'end worker_3'

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=worker_1, args=(1,))
    p2 = multiprocessing.Process(target=worker_2, args=(2,))
    p3 = multiprocessing.Process(target=worker_3, args=(3,))

    p1.start()
    p2.start()
    p3.start()

    print 'The number of CPU is:' + str(multiprocessing.cpu_count())
    for p in multiprocessing.active_children():
        print 'child p.name:' + p.name + '\tp.id' + str(p.pid)
    print 'END!!!!!!!!!!!'

import multiprocessing
import time

class ClockProcess(multiprocessing.Process):
    def __init__(self, interval):
        multiprocessing.Process.__init__(self)
        self.interval = interval

    def run(self):
        n = 5
        while n >0:
            print 'The time is {0}'.format(time.ctime())
            time.sleep(self.interval)
            n -= 1

if __name__ == '__main__':
    p = ClockProcess(3)
    p.start()

import multiprocessing
import time

def worker(interval):
    print 'worker start:{0}'.format(time.ctime())
    time.sleep(interval)
    print 'worker end:{0}'.format(time.ctime())

if __name__ == '__main__':
    p = multiprocessing.Process(target=worker, args=(3,))
    p.daemon = True
    p.start()
    p.join()
    print 'end'

import multiprocessing
import sys

def worker_with(lock, f):
    with lock:
        fs = open(f, 'a+')
        n = 10
        while n > 1:
            fs.write('Lock acquired via with\n')
            n -= 1
        fs.close

def worker_no_with(lock, f):
    lock.acquire()
    try:
        fs = open(f, 'a+')
        n = 10
        while n > 1:
            fs.write('Lock acquired directly\n')
            n -= 1
        fs.close()
    finally:
        lock.release()

if __name__ == '__main__':
    lock = multiprocessing.Lock()
    f = 'file.txt'
    w = multiprocessing.Process(target=worker_with, args=(lock, f))
    nw = multiprocessing.Process(target=worker_no_with, args=(lock, f))
    w.start()
    nw.start()
    print 'end'
    

import multiprocessing
import time

def worker(s, i):
    s.acquire()
    print(multiprocessing.current_process().name +'acquire')
    time.sleep(i)
    print(multiprocessing.current_process().name + 'release')
    s.release()

if __name__ == '__main__':
    s = multiprocessing.Semaphore(2)
    for i in range(5):
        print i
        p = multiprocessing.Process(target=worker, args=(s, i))
        p.start()

import multiprocessing
import time

def wait_for_event(e):
    print 'wait_for_event: starting'
    e.wait()
    print 'wait_for_event: e.is_set()->' + str(e.is_set())

def wait_for_event_timeout(e, t):
    print 'wait_for_event_timeout: starting'
    e.wait(t)
    print 'wait_for_event_timeout: e.is_set()->' + str(e.is_set())

if __name__ == '__main__':
    e = multiprocessing.Event()
    w1 = multiprocessing.Process(name='block',
                                 target=wait_for_event,
                                 args=(e,))
    w2 = multiprocessing.Process(name='non-block',
                                 target=wait_for_event_timeout,
                                 args=(e,2))
    w1.start()
    w2.start()
    time.sleep(3)
    e.set()
    print 'main: event is set'

import multiprocessing
import time

def proc1(pipe):
    while True:
        for i in xrange(10):
            print 'proc1 send: %s' % (i)
            pipe.send(i)
            time.sleep(1)

def proc2(pipe):
    while True:
        print 'proc2 rev:', pipe.recv()
        time.sleep(1)

if __name__ == '__main__':
    pipe = multiprocessing.Pipe()
    p1 = multiprocessing.Process(target=proc1, args=(pipe[0],))
    p2 = multiprocessing.Process(target=proc2, args=(pipe[1],))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

import multiprocessing

def writer_proc(q):
    try:
        q.put(1, block=False)
        q.put(2, block=False)
        q.put(3, block=False)
    except:
        pass

def reader_proc(q):
    try:
        print q.get(block=False)
        print q.get(block=False)
        print q.get(block=False)
    except:
        pass

if __name__ == '__main__':
    q = multiprocessing.Queue()
    writer = multiprocessing.Process(target=writer_proc, args=(q,))
    writer.start()

    reader = multiprocessing.Process(target=reader_proc, args=(q,))
    reader.start()

    reader.join()
    writer.join()