Thread and shared lock

在看programing python 4th，第5张parallel system tool 192页开始，书中讲到thread知识，以下做个笔记，以便后期学习

1.主线程执行，开启5个子线程进行计数，没有使用mutex锁住，所以线程没有lock住资源，每个线程对全局变量的操作错乱，结果如下：

 """
 synchronize access to stdout: because it is shared global
 thread outputs may be intermixed if not syschronized
 """
 import thread,time
 global num                                  #global var to be used by many threads
 num=0

 def cnt(id,count):                          # function run in threads
     for i in range(count):
         global num
         #mutex.acquire()                     # lock the share var before execute
         num +=1
         time.sleep(0.5)                     # simulate read work
         print('[%s] num= %s\n' %(id,num))   #print isn't interrupted now
         #mutex.release()                     #release the lock for the other thread

 if __name__ =="__main__":
     #mutex=thread.allocate_lock()            #make a global mutex for lock
     for i in range(5):                      #spawm 5 threads
         thread.start_new_thread(cnt,(i,3))  #start threads
     time.sleep(8)                          # wait for spawn thread work done,don't exit too early

     print('main thread exitting')

2.把mutex 注释打开，有了mutex变量，每一个线程进入都会独占num变量，结果如下：

 """
 synchronize access to stdout: because it is shared global
 thread outputs may be intermixed if not syschronized
 """
 import thread,time
 global num                                  #global var to be used by many threads
 num=0

 def cnt(id,count):                          # function run in threads
     for i in range(count):
         global num
         mutex.acquire()                     # lock the share var before execute
         num +=1
         time.sleep(0.5)                     # simulate read work
         print('[%s] num= %s\n' %(id,num))   #print isn't interrupted now
         mutex.release()                     #release the lock for the other thread

 if __name__ =="__main__":
     mutex=thread.allocate_lock()            #make a global mutex for lock
     for i in range(5):                      #spawm 5 threads
         thread.start_new_thread(cnt,(i,3))  #start threads
     time.sleep(8)                          # wait for spawn thread work done,don't exit too early

     print('main thread exitting')

3.如果把time.sleep(6)注释掉或者子线程没有执行完毕，而主线程sleep的时间一到，主线程直接退出而不等待子线程执行完毕，结果如下：

a.主线程不等待，则直接退出

b.主线程只等待3s，而5个子线程需要7.5s，所以num只计数5.

4.设定有效等待时间和锁之后，主线程等待所有子线程执行结束才退出，结果如下：

6.无需在主线程设置等待时间，而是设定单独的锁或者变量来记录每个子线程的执行状态，每执行完一个线程，设定状态锁，然后在主线程判断所有状态锁的状态即可

 """
 used mutexex to know when threads are done in parent/main thread,
 instead of time.sleep;lock stdout to avoid comingled prints
 """
 import thread,time
 global num
 num =0

 def cnt(id,count):
     for i in range(count):
         global num
         stdoutmutex.acquire()
         num +=1
         time.sleep(0.5)
         print('[%s] num= %s time:[%s]\n' %(id,num,time.ctime()))   #print isn't interrupted now
         stdoutmutex.release()
     #exitmutexs[id].acquire() # signal main thread
     exitFlags[id] = True     #signal main thread

 if __name__ =="__main__":
     stdoutmutex = thread.allocate_lock()                           #make a global mutex for lock
     #exitmutexs = [thread.allocate_lock() for i in range(5)]
     exitFlags=[False]*5
     for i in range(5):                                             #spawm 5 threads
         thread.start_new_thread(cnt,(i,3))                         #start threads
     #for mutex in exitmutexs:
     #    while not mutex.locked():
     #        pass
     while False in exitFlags:pass
     print('main thread exitting')