黄色网页视频 I 影音先锋日日狠狠久久 I 秋霞午夜毛片 I 秋霞一二三区 I 国产成人片无码视频 I 国产 精品 自在自线 I av免费观看网站 I 日本精品久久久久中文字幕5 I 91看视频 I 看全色黄大色黄女片18 I 精品不卡一区 I 亚洲最新精品 I 欧美 激情 在线 I 人妻少妇精品久久 I 国产99视频精品免费专区 I 欧美影院 I 欧美精品在欧美一区二区少妇 I av大片网站 I 国产精品黄色片 I 888久久 I 狠狠干最新 I 看看黄色一级片 I 黄色精品久久 I 三级av在线 I 69色综合 I 国产日韩欧美91 I 亚洲精品偷拍 I 激情小说亚洲图片 I 久久国产视频精品 I 国产综合精品一区二区三区 I 色婷婷国产 I 最新成人av在线 I 国产私拍精品 I 日韩成人影音 I 日日夜夜天天综合

python多線程

系統(tǒng) 2078 0

python多線程深入理解

  • 低級(jí)接口
    • 基本使用
    • Event
    • Semaphore
    • 線程通信
  • 高級(jí)接口

低級(jí)接口

基本使用

join()方法用來(lái)阻塞主線程??梢宰⑨尩?、看看打印順序。

            
              
                import
              
               threading

              
                import
              
               time


              
                def
              
              
                test
              
              
                (
              
              n
              
                )
              
              
                :
              
              
    time
              
                .
              
              sleep
              
                (
              
              
                1
              
              
                )
              
              
                print
              
              
                (
              
              n
              
                )
              
              

t 
              
                =
              
               threading
              
                .
              
              Thread
              
                (
              
              target
              
                =
              
              test
              
                ,
              
               args
              
                =
              
              
                (
              
              
                7
              
              
                ,
              
              
                )
              
              
                )
              
              
t
              
                .
              
              start
              
                (
              
              
                )
              
              
t
              
                .
              
              join
              
                (
              
              
                )
              
              
                # 等待子線程執(zhí)行完畢,才繼續(xù)執(zhí)行主線程。
              
              
                print
              
              
                (
              
              
                '主線程執(zhí)行完畢'
              
              
                )
              
            
          

Event

當(dāng) Event 被激活時(shí)候,所有等待 Event 的線程將全部激活!
event.set() 用來(lái)激活, event.wait() 等待事件發(fā)生。

            
              
                import
              
               threading

              
                import
              
               time


              
                def
              
              
                produce
              
              
                (
              
              n
              
                ,
              
               ee
              
                )
              
              
                :
              
              
    time
              
                .
              
              sleep
              
                (
              
              
                1
              
              
                )
              
              
                print
              
              
                (
              
              n
              
                )
              
              
                print
              
              
                (
              
              
                'go !!!'
              
              
                )
              
                  
    ee
              
                .
              
              
                set
              
              
                (
              
              
                )
              
              
                def
              
              
                consumer
              
              
                (
              
              n
              
                ,
              
               ee
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                'wait'
              
              
                )
              
                  
    ee
              
                .
              
              wait
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              f
              
                '{n} running......'
              
              
                )
              
              

ee 
              
                =
              
               threading
              
                .
              
              Event
              
                (
              
              
                )
              
              
m 
              
                =
              
               threading
              
                .
              
              Thread
              
                (
              
              target
              
                =
              
              produce
              
                ,
              
               args
              
                =
              
              
                (
              
              
                0
              
              
                ,
              
               ee
              
                )
              
              
                )
              
              
t 
              
                =
              
               threading
              
                .
              
              Thread
              
                (
              
              target
              
                =
              
              consumer
              
                ,
              
               args
              
                =
              
              
                (
              
              
                1
              
              
                ,
              
               ee
              
                )
              
              
                )
              
              
t
              
                .
              
              start
              
                (
              
              
                )
              
              
                # m.start()
              
            
          

Semaphore

當(dāng)信號(hào)量被釋放,其他線程才能競(jìng)爭(zhēng)這個(gè)信號(hào)量。
只有當(dāng)線程通過(guò)競(jìng)爭(zhēng) 獲取到這個(gè)信號(hào)量,才能繼續(xù)執(zhí)行程序。

            
              
                from
              
               threading 
              
                import
              
               Semaphore
              
                ,
              
               Thread

              
                from
              
               time 
              
                import
              
               sleep


              
                def
              
              
                worker
              
              
                (
              
              n
              
                ,
              
               sema
              
                )
              
              
                :
              
                  
    sema
              
                .
              
              acquire
              
                (
              
              
                )
              
                  
    sleep
              
                (
              
              
                1
              
              
                )
              
              
                print
              
              
                (
              
              n
              
                )
              
              
                # breakpoint()    
              
              
    sema
              
                .
              
              release
              
                (
              
              
                )
              
              

sema 
              
                =
              
               Semaphore
              
                (
              
              
                5
              
              
                )
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
   t 
              
                =
              
               Thread
              
                (
              
              target
              
                =
              
              worker
              
                ,
              
               args
              
                =
              
              
                (
              
              i
              
                ,
              
               sema
              
                )
              
              
                )
              
                  
   t
              
                .
              
              start
              
                (
              
              
                )
              
            
          

線程通信

使用queue即可。用put()方法入隊(duì),get()方法獲取隊(duì)列元素。

            
              
                from
              
               queue 
              
                import
              
               Queue

              
                import
              
               threading

              
                import
              
               time



              
                def
              
              
                producer
              
              
                (
              
              q
              
                )
              
              
                :
              
              
                while
              
              
                True
              
              
                :
              
              
        time
              
                .
              
              sleep
              
                (
              
              
                5
              
              
                )
              
              
        q
              
                .
              
              put
              
                (
              
              
                'apple'
              
              
                )
              
              
                def
              
              
                consumer
              
              
                (
              
              q
              
                )
              
              
                :
              
              
                while
              
              
                True
              
              
                :
              
              
                print
              
              
                (
              
              f
              
                'eat {q.get()}'
              
              
                )
              
              
                if
              
               __name__ 
              
                ==
              
              
                '__main__'
              
              
                :
              
              
    q 
              
                =
              
               Queue
              
                (
              
              maxsize
              
                =
              
              
                5
              
              
                )
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
        t1 
              
                =
              
               threading
              
                .
              
              Thread
              
                (
              
              target
              
                =
              
              producer
              
                ,
              
               args
              
                =
              
              
                (
              
              q
              
                ,
              
              
                )
              
              
                )
              
              
        t1
              
                .
              
              start
              
                (
              
              
                )
              
              
    t2 
              
                =
              
               threading
              
                .
              
              Thread
              
                (
              
              target
              
                =
              
              consumer
              
                ,
              
               args
              
                =
              
              
                (
              
              q
              
                ,
              
              
                )
              
              
                )
              
              
    t2
              
                .
              
              start
              
                (
              
              
                )
              
            
          

高級(jí)接口

請(qǐng)參考concurrent.futures模塊

參考寫(xiě)法一(submit()):

            
              
                from
              
               concurrent
              
                .
              
              futures 
              
                import
              
               ThreadPoolExecutor
              
                ,
              
              ProcessPoolExecutor
              
                ,
              
              as_completed

              
                import
              
               time
              
                ,
              
              random



              
                def
              
              
                mytimeit
              
              
                (
              
              f
              
                )
              
              
                :
              
              
                def
              
              
                ret
              
              
                (
              
              
                )
              
              
                :
              
              
        start_time 
              
                =
              
               time
              
                .
              
              time
              
                (
              
              
                )
              
              
        f
              
                (
              
              
                )
              
              
        end_time 
              
                =
              
               time
              
                .
              
              time
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              
                'timeit : '
              
              
                ,
              
              end_time
              
                -
              
              start_time
              
                )
              
              
                return
              
               ret



              
                def
              
              
                ppow
              
              
                (
              
              a
              
                ,
              
              b
              
                )
              
              
                :
              
              
    time
              
                .
              
              sleep
              
                (
              
              
                1
              
              
                )
              
              
                return
              
              
                pow
              
              
                (
              
              a
              
                ,
              
              b
              
                )
              
              

@mytimeit

              
                def
              
              
                run
              
              
                (
              
              
                )
              
              
                :
              
              
                with
              
               ThreadPoolExecutor
              
                (
              
              max_workers
              
                =
              
              
                1000
              
              
                )
              
              
                as
              
               executor
              
                :
              
              
        all_tasks 
              
                =
              
              
                {
              
              executor
              
                .
              
              submit
              
                (
              
              ppow
              
                ,
              
              
                2
              
              
                ,
              
              j
              
                )
              
              
                :
              
              j 
              
                for
              
               j 
              
                in
              
              
                range
              
              
                (
              
              
                10000
              
              
                )
              
              
                }
              
              
                for
              
               task 
              
                in
              
               as_completed
              
                (
              
              all_tasks
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              task
              
                .
              
              result
              
                (
              
              
                )
              
              
                ,
              
              all_tasks
              
                [
              
              task
              
                ]
              
              
                )
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    run
              
                (
              
              
                )
              
            
          

參考寫(xiě)法二(map()):

            
              
                # python3.7 
              
              
                # 更新pip安裝的模塊(多進(jìn)程)
              
              
                # 想用多線程,只需要把文件里的ProcessPoolExecutor全部替換成ThreadPoolExecutor即可
              
              
                import
              
               subprocess

              
                from
              
               concurrent
              
                .
              
              futures 
              
                import
              
               ProcessPoolExecutor

res 
              
                =
              
               subprocess
              
                .
              
              run
              
                (
              
              
                'pip list -o'
              
              
                ,
              
              capture_output
              
                =
              
              
                True
              
              
                ,
              
              text
              
                =
              
              
                True
              
              
                )
              
              
                # 獲取需要更新的模塊
              
              
need_update
              
                =
              
              
                [
              
              item
              
                .
              
              split
              
                (
              
              
                ' '
              
              
                )
              
              
                [
              
              
                0
              
              
                ]
              
              
                for
              
               item 
              
                in
              
               res
              
                .
              
              stdout
              
                .
              
              split
              
                (
              
              
                '\n'
              
              
                )
              
              
                [
              
              
                2
              
              
                :
              
              
                ]
              
              
                ]
              
              
                with
              
               ProcessPoolExecutor
              
                (
              
              max_workers 
              
                =
              
              
                100
              
              
                )
              
              
                as
              
               exe
              
                :
              
              
    exe
              
                .
              
              
                map
              
              
                (
              
              subprocess
              
                .
              
              run
              
                ,
              
              
                [
              
              f
              
                'pip install -U {name}'
              
              
                for
              
               name 
              
                in
              
               need_update 
              
                if
              
               name
              
                ]
              
              
                )
              
            
          

上面這個(gè)可能無(wú)法運(yùn)行

            
              
                import
              
               subprocess

              
                from
              
               concurrent
              
                .
              
              futures 
              
                import
              
               ProcessPoolExecutor

res 
              
                =
              
               subprocess
              
                .
              
              run
              
                (
              
              
                'pip list -o -i https://mirrors.aliyun.com/pypi/simple'
              
              
                .
              
              split
              
                (
              
              
                )
              
              
                ,
              
              stdout
              
                =
              
              subprocess
              
                .
              
              PIPE
              
                )
              
              
                # 獲取需要更新的模塊
              
              
need_update
              
                =
              
              
                [
              
              item
              
                .
              
              split
              
                (
              
              
                ' '
              
              
                )
              
              
                [
              
              
                0
              
              
                ]
              
              
                for
              
               item 
              
                in
              
              
                str
              
              
                (
              
              res
              
                )
              
              
                .
              
              split
              
                (
              
              
                '\\n'
              
              
                )
              
              
                [
              
              
                2
              
              
                :
              
              
                ]
              
              
                ]
              
              
                print
              
              
                (
              
              need_update
              
                )
              
              
                with
              
               ProcessPoolExecutor
              
                (
              
              max_workers 
              
                =
              
              
                100
              
              
                )
              
              
                as
              
               exe
              
                :
              
              
    exe
              
                .
              
              
                map
              
              
                (
              
              subprocess
              
                .
              
              run
              
                ,
              
              
                [
              
              
                'pip install -i https://mirrors.aliyun.com/pypi/simple -U {}'
              
              
                .
              
              
                format
              
              
                (
              
              name
              
                )
              
              
                .
              
              split
              
                (
              
              
                )
              
              
                for
              
               name 
              
                in
              
               need_update 
              
                if
              
               name
              
                ]
              
              
                )
              
            
          

更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號(hào)聯(lián)系: 360901061

您的支持是博主寫(xiě)作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點(diǎn)擊下面給點(diǎn)支持吧,站長(zhǎng)非常感激您!手機(jī)微信長(zhǎng)按不能支付解決辦法:請(qǐng)將微信支付二維碼保存到相冊(cè),切換到微信,然后點(diǎn)擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對(duì)您有幫助就好】

您的支持是博主寫(xiě)作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長(zhǎng)會(huì)非常 感謝您的哦?。。?/p>

發(fā)表我的評(píng)論
最新評(píng)論 總共0條評(píng)論