并發與鎖

• a. 多個線程共享數據的時候，如果數據不進行保護，那么可能出現數 據不一致現象，使用鎖，信號量、條件鎖
  • b.
    • c. 互斥鎖
      1. 互斥鎖，是使用一把鎖把代碼保護起來，以犧牲性能換取代碼的安全性，那么Rlock后 必須要
      relase 解鎖 不然將會失去多線程程序的優勢
      2. 互斥鎖的基本使用規則：
      

                              1 
                              
                                import
                              
                              
                                 threading
      
                              
                              2 
                              
                                #
                              
                              
                                 聲明互斥鎖
                              
                              
      3 lock=
                              
                                threading.Rlock();
      
                              
                              4 
                              
                                def
                              
                               handle(sid):
                              
                                #
                              
                              
                                 功能實現代碼
                              
                              
      5 lock.acquire() 
                              
                                #
                              
                              
                                加鎖
                              
                              
      6 
                              
                                #
                              
                              
                                 writer codeing
                              
                              
      7 lock.relase() 
                              
                                #
                              
                              
                                釋放鎖
                              
                            

      8
      信號量：
      1. 調用relarse(）信號量會+1 調用 acquire() 信號量會-1
      a. 可以理解為對于臨界資源的使用，以及進入臨界區的判斷條件
      2. semphore() :當調用relarse()函數的時候 單純+1 不會檢查信號量的上限情況。 初
      始參數為0
      3. boudedsemphore()：邊界信號量 當調用relarse() 會+1 , 并且會檢查信號量的上
      限情況。不允許超過上限
      a. 使用budedsemaphore時候不允許設置初始為0，將會拋出異常
      b. 至少設置為1 ，如consumer product 時候應該在外設置一個變
      量，啟動時候對變量做判斷，決定使不使用acquier
      4. 信號量的基本使用代碼：
      

                              1 
                              
                                #
                              
                              
                                 聲明信號量：
                              
                              
      2 sema=threading.Semaphore(0); 
                              
                                #
                              
                              
                                無上限檢查
                              
                              
      3 sema=threading.BuderedSeamphore(1) 
                              
                                #
                              
                              
                                有上限檢查設置
                              
                              
      4 5
                              
                                
      apple
                              
                              =1
      6 
                              
                                def
                              
                              
                                 consumner():
      
                              
                              7 seam.acquire(); 
                              
                                #
                              
                              
                                 ‐1
                              
                              
      8 9
      
                              
                                if
                              
                               apple==1
                              
                                :
      
                              
                              10 
                              
                                pass
                              
                              
      11 
                              
                                else
                              
                              : sema2.release();
                              
                                #
                              
                              
                                + 1
                              
                              
      12 
                              
                                def
                              
                              
                                 product():
      
                              
                              13 seam.relarse(); 
                              
                                #
                              
                              
                                 +1
                              
                              
      14 
                              
                                if
                              
                               apple==1
                              
                                :
      
                              
                              15 
                              
                                pass
                              
                              
      16 
                              
                                else
                              
                              
                                :
      
                              
                              17 
                              
                                print
                              
                              (
                              
                                "
                              
                              
                                消費：
                              
                              
                                "
                              
                              
                                ,apple);
      
                              
                              18 
                              
      
                              
      
                            

      
      
      
    • 全部的代碼：

    •                         
                                #
                              
                              
                                 -*- coding: utf-8 -*-
                              
                              
                                """
                              
                              
                                
      Created on Mon Sep  9 21:49:30 2019
      
      @author: DGW-PC
      
                              
                              
                                """
                              
                              
                                #
                              
                              
                                 信號量解決生產者消費者問題
                              
                              
                                import
                              
                              
                                 random;
      
                              
                              
                                import
                              
                              
                                 threading;
      
                              
                              
                                import
                              
                              
                                 time;
      
      
                              
                              
                                #
                              
                              
                                 聲明信號量
                              
                              
      sema=threading.Semaphore(0);
                              
                                #
                              
                              
                                 必須寫參數 0 表示可以使用數
                              
                              
      sema2=threading.BoundedSemaphore(1
                              
                                );
      
      apple
                              
                              =1
                              
                                ;
      
      
                              
                              
                                def
                              
                               product():
                              
                                #
                              
                              
                                生產者
                              
                              
                                global
                              
                              
                                 apple;
          apple
                              
                              =random.randint(1,100
                              
                                );
          time.sleep(
                              
                              3
                              
                                );
          
                              
                              
                                print
                              
                              (
                              
                                "
                              
                              
                                生成蘋果:
                              
                              
                                "
                              
                              
                                ,apple);
          
                              
                              
                                #
                              
                              
                                sema2.release(); # +1
                              
                              
                                if
                              
                               apple==1
                              
                                :
               
                              
                              
                                pass
                              
                              
                                else
                              
                              : sema2.release();
                              
                                #
                              
                              
                                + 1 
                              
                              
                                def
                              
                              
                                 consumer():
          
                              
                              
                                print
                              
                              (
                              
                                "
                              
                              
                                等待
                              
                              
                                "
                              
                              
                                );
          sema2.acquire();
                              
                              
                                #
                              
                              
                                 -1
                              
                              
                                if
                              
                               apple==1
                              
                                :
              
                              
                              
                                pass
                              
                              
                                else
                              
                              
                                :        
              
                              
                              
                                print
                              
                              (
                              
                                "
                              
                              
                                消費：
                              
                              
                                "
                              
                              
                                ,apple);
          
      
      threads
                              
                              =
                              
                                [];
      
      
                              
                              
                                for
                              
                               i 
                              
                                in
                              
                               range(1,3
                              
                                ):
          t1
                              
                              =threading.Thread(target=
                              
                                consumer);
          t2
                              
                              =threading.Thread(target=
                              
                                product);
          t1.start();
          t2.start();
          threads.append(t1);
          threads.append(t2);
      
                              
                              
                                for
                              
                               x 
                              
                                in
                              
                              
                                 threads:
          x.join();
      
          
          
                              
                            

      ?