python 多线程示例1

多线程真是太复杂了，C语言里面，就是不返回任何值的void *的函数。但是当我看到那一本a little book of semaphore. 就想死
更别说还有mutex, spinlock, condition ,复杂啊。
看python 的threading module 好像要简单一些，但是毕竟也不知道Cpython是怎么实现的。
anyway，先存点代码留待以后慢慢看。
1. 这个代码我注视了join, main-thread 会默认等待非daemon 的线程。所以join 感觉并不需要。

def thread_1():
    def countdown(n):
        while n > 0:
            print('T -minus ',n)
            n-=1
            time.sleep(1)

    #create and launch a thread

    t=threading.Thread(target=countdown,args=(10,))
    t.start()
    while True:
        if t.is_alive():
            print("Still running")
            time.sleep(1)
        else:
            print('Completed')
            break

    #t.join()

thread_1()

2. 从主线程去停止其他线程，这难道是C语言的signal 吗？不清楚

class CountdownTask:
    def __init__(self):
        self._running=True

    def terminate(self):
        self._running=False

    def run(self,n):
        while self._running and n >0:
            print('T - minus',n)
            n-=1
            time.sleep(1)

def thread2():
    c = CountdownTask()
    t = threading.Thread(target=c.run, args=(10,))
    t.start()
    if t.is_alive():
        print("Still running")
    else:
        print('Completed')
    c.terminate() # Signal termination
    t.join() # Wait for actual termination (if needed)


#thread2()

3. Event 做线程通信。只有4个方法
主线程调用wait ,等待子线程set()之后 主线程继续执行

is_set()：Return true if and only if the internal flag is true.
set():Set the internal flag to true. All threads waiting for it to become true are awakened. Threads that call wait() once the flag is true will not block at all.
clear():Reset the internal flag to false
wait(timeout=None): Block until the internal flag is true. If the internal flag is true on entry, return immediately. Otherwise, block until another thread calls set() to set the flag to true, or until the optional timeout occurs.

logging.basicConfig(level=logging.DEBUG,format='%(asctime)s (%(threadName)-10s) %(message)s',)

def thread3():
    # Code to execute in an independent thread
    def countdown(n,started_evt):
        print('countdown starting')
        started_evt.set()
        while n>0:
            logging.debug('T-minus {}'.format(n))
            n-=1
            time.sleep(1)

    # Create the event object that will be used to signal startup
    started_evt=threading.Event()

    ## Launch the thread and pass the startup event
    logging.debug('Launching countdown')
    t=threading.Thread(target=countdown,args=(10,started_evt))
    t.start()
    logging.debug("Event is set or not {}:".format(started_evt.is_set()))
    #wait for the thread to start
    started_evt.wait()
    logging.debug('Countdwon is running')

thread3()

4.  对于set daemon的线程，应该显式的join,去等待。
默认join 会一直blocking, 但是可以传给它一个float。 If the thread does not complete within the timeout period, join() returns anyway

def determine_current_thread():
    def daemon():
        logging.debug("starting")
        time.sleep(2)
        logging.debug("Exiting")

    def non_daemon():
        logging.debug("starting")
        logging.debug("Exiting")

    d=threading.Thread(name="daemon",target=daemon)
    d.setDaemon(True)

    t=threading.Thread(name="non-daemon",target=non_daemon)

    d.start()
    t.start()

    t.join()
    print("d.isAlive() {}".format(d.isAlive()))
    #d.join(timeout=1)
    d.join()

#determine_current_thread()

5. 使用enumerate 获取线程的列表，不能对主线程join,会造成死锁。

#enumerate() returns a list of active Thread instances. The list includes the current thread,
#since joining the current thread is not allowed (it introduces a deadlock situation), it must be skipped
def thread_enumerate():
    def worker():
        #threwad worker function
        t=threading.currentThread()
        pause=random.randint(1,5)
        logging.debug("sleeping {}".format(pause))
        time.sleep(pause)
        logging.debug("ending")
        return

    for i in range(3):
        t=threading.Thread(target=worker)
        t.setDaemon(True)
        t.start()

    main_thread=threading.currentThread()
    for t in threading.enumerate():
        if t is main_thread:
            continue
        logging.debug("joing {}".format(t.getName()))
        t.join()

#thread_enumerate()

6. 仍然是个使用Event 做线程signal 传递的例子。

#signal between threads, easy way to do this is with Event object
# An Event manages an internal flag that callers can either set() or clear(). Other threads can wait() for the flag to be set(),
#effectively blocking progress until allowed to continue
#In this example, wait_for_event_timeout() checks the event status without blocking indefinitely.
#The wait_for_event() blocks on the call to wait(), which does not return until the event status changes.
def signal_event():
    def wait_for_event(e):
        #wait for the event to be set before doing any thing
        logging.debug("wait_for_event starting")
        event_is_set=e.wait()
        logging.debug("event set: {}".format(event_is_set))

    def wait_for_event_timeout(e,t):
        #wait t seconds and then timeout
        while not e.isSet():
            logging.debug("Waiting_for_event_timeout starting")
            event_is_set=e.wait(t)
            logging.debug("event set {}".format(event_is_set))
            if event_is_set:
                logging.debug("processing event")
            else:
                logging.debug("doing other work")

    e=threading.Event()
    t1=threading.Thread(name="block",target=wait_for_event,args=(e,))
    t1.start()

    t2=threading.Thread(name="non-block",target=wait_for_event_timeout,args=(e,2))
    t2.start()

    logging.debug("Waiting before calling Event.set()")
    time.sleep(3)
    e.set()
    logging.debug("Event is set")

signal_event()

Bonus:
使用cProfile 看看都做了些啥。

import cProfile
cProfile.run('signal_event()')

(block ) wait_for_event starting
(non-block ) Waiting_for_event_timeout starting
(MainThread) Waiting before calling Event.set()
(non-block ) event set False
(non-block ) doing other work
(non-block ) Waiting_for_event_timeout starting
(MainThread) Event is set
(block ) event set: True
         228 function calls in 3.021 seconds

   Ordered by: standard name

参考资料：