python多線程實現

simon_chen 發布于2019-07-30 14:49 / 1402人閱讀

摘要：中的多線程我參考了中的介紹，介紹的很入門很詳細。如只設置了第個和第個，沒有設置這只會掉第個子線程個人猜測，當程序運行完主線程后則會檢查剩余的子線程，將最后面的且是子進程刪掉。第個沒有掉是因為線程還在運行并且是默認狀態不能被的。

本人初學者開始第一篇博客，記錄學習的點點滴滴，以作為備忘錄，也希望能同大家一起分享。有理解錯誤的地方希望大家指正。 python中的多線程我參考了（http://www.cnblogs.com/fnng/p...）中的介紹，介紹的很入門很詳細。介紹了threading的基本用法。

最簡單的情況是：

import threading
import time
def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep(2)               #子程序等2秒。。
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
print("程序結束，%s:"%(time.ctime()))

#輸出為-------------------
我是第1個進程,開始時間是Sun Oct 22 17:45:37 2017
我是第2個進程,開始時間是Sun Oct 22 17:45:37 2017
我是第3個進程,開始時間是Sun Oct 22 17:45:37 2017
我是第4個進程,開始時間是Sun Oct 22 17:45:37 2017
我是第5個進程,開始時間是Sun Oct 22 17:45:37 2017
**程序結束，Sun Oct 22 17:45:37 2017:**          #主線程繼續執行，不等待，也不殺死子線程
我是第1個進程,結束時間是Sun Oct 22 17:45:39 2017
我是第2個進程,結束時間是Sun Oct 22 17:45:39 2017
我是第5個進程,結束時間是Sun Oct 22 17:45:39 2017
我是第3個進程,結束時間是Sun Oct 22 17:45:39 2017
我是第4個進程,結束時間是Sun Oct 22 17:45:39 2017

這里介紹另外兩個函數:setDaemon()、join()
join：如在一個線程B中調用threada.join()，則threada結束后，線程B才會接著threada.join()往后運行。
setDaemon：主線程A啟動了子線程B，調用b.setDaemaon(True)，則主線程結束時，會把子線程B也殺死，與C/C++中得默認效果是一樣的。

比如我想讓主程序等待子程序完成之后再運行，可以是用t.join()
其中t是指某個子進程，如t1,t2....然后join()可以有一個參數，主進程等待多少秒，如t1.join(2)指在t1子進程開始后，主進程等待2秒就繼續執行。

def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep(i*2)               #模擬子進程的運行時間，ID越大時間越長
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
threads[1].join(1)              #主進程在第二個子進程開始后阻塞1秒再運行
print("主進程：，%s:"%(time.ctime()))

#輸出---------------------
我是第1個進程,開始時間是Sun Oct 22 18:12:14 2017
我是第1個進程,結束時間是Sun Oct 22 18:12:14 2017
我是第2個進程,開始時間是Sun Oct 22 18:12:14 2017     #第二個子進程14秒開始
我是第3個進程,開始時間是Sun Oct 22 18:12:14 2017
我是第4個進程,開始時間是Sun Oct 22 18:12:14 2017
我是第5個進程,開始時間是Sun Oct 22 18:12:14 2017
主進程：Sun Oct 22 18:12:15 2017:                  #主進程在阻塞一秒后的15秒開始啟動運行
我是第2個進程,結束時間是Sun Oct 22 18:12:16 2017
我是第3個進程,結束時間是Sun Oct 22 18:12:18 2017
我是第4個進程,結束時間是Sun Oct 22 18:12:20 2017
我是第5個進程,結束時間是Sun Oct 22 18:12:22 2017

若想等所有的子進程都完成后，主進程在進行可以，簡單情況可以用最慢的一個子進程來對主進程進行阻塞，這里最慢的是第5個子進程。可以：threads[4].join()。

import tensorflow as tf
import numpy as np
import random
import threading
import time


def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模擬子程序運行隨機秒
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]
for t in threads:
    t.start()
threads[4].join()
print("主進程：%s:"%(time.ctime()))

#輸出-----------------------
我是第1個進程,開始時間是Sun Oct 22 18:29:28 2017
我是第2個進程,開始時間是Sun Oct 22 18:29:28 2017
我是第3個進程,開始時間是Sun Oct 22 18:29:28 2017
我是第4個進程,開始時間是Sun Oct 22 18:29:28 2017
我是第5個進程,開始時間是Sun Oct 22 18:29:28 2017
我是第1個進程,結束時間是Sun Oct 22 18:29:29 2017
我是第2個進程,結束時間是Sun Oct 22 18:29:31 2017
我是第3個進程,結束時間是Sun Oct 22 18:29:33 2017
我是第4個進程,結束時間是Sun Oct 22 18:29:35 2017
我是第5個進程,結束時間是Sun Oct 22 18:29:37 2017
主進程：Sun Oct 22 18:29:37 2017:                      #主進程等到最后一個子進程結束后才運行

另一種情況是，比如我想讓主程序運行完就立刻結束，殺死子程序：可以用t.setDaemon(True)

def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模擬子程序運行隨機秒
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

for t in threads:
    t.setDaemon(True)
    t.start()
print("主進程：%s:"%(time.ctime()))

#輸出---------------------------------
我是第1個進程,開始時間是Sun Oct 22 19:04:06 2017
我是第2個進程,開始時間是Sun Oct 22 19:04:06 2017
我是第3個進程,開始時間是Sun Oct 22 19:04:06 2017
我是第4個進程,開始時間是Sun Oct 22 19:04:06 2017
我是第5個進程,開始時間是Sun Oct 22 19:04:06 2017
主進程：Sun Oct 22 19:04:06 2017:                 #可以看到主線程完成后，后面就沒有子線程了。

一種特殊情況請注意：當并非像上面每個子進程一樣都設置t.setDaemon(True)（有的設置有的沒有。。）
如：

threads[2].setDaemon(True)   #只設置了第3個和第5個，1,2,4沒有設置這只會kill掉第5個子線程
                             #個人猜測，當程序運行完主線程后則會檢查剩余的子線程，將最后面的                             
threads[4].setDaemon(True)   #且是setDaemon(True) 子進程刪掉。第3個沒有kill掉是因為4線程還在運行
for t in threads:            #并且4是默認狀態不能被kill的。這時主進程依然在等待4完成而不會
    t.start()                #殺掉剩余進程，當4完成了，就不等待了直接殺掉剩余進程

我們可以這樣驗證，在線程4結束前看看線程5是否存活：

import tensorflow as tf
import numpy as np
import random
import threading
import time


def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模擬子程序運行隨機秒
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
    if i ==3:
        print("我是第4個進程：結束前進程5的狀態是：" ,threads[4].is_alive())   #加這一句判斷現成物
                                                                            #的存活情況
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

#threads[0].setDaemon(True)
#threads[1].setDaemon(True)
threads[2].setDaemon(True)
#threads[3].setDaemon(True)
threads[4].setDaemon(True)

for t in threads:
    t.start()
print("主進程：%s:"%(time.ctime()))

#輸出----------------------------------
我是第1個進程,開始時間是Sun Oct 22 19:22:36 2017
我是第2個進程,開始時間是Sun Oct 22 19:22:36 2017
我是第3個進程,開始時間是Sun Oct 22 19:22:36 2017
我是第4個進程,開始時間是Sun Oct 22 19:22:36 2017
我是第5個進程,開始時間是Sun Oct 22 19:22:36 2017
主進程：Sun Oct 22 19:22:36 2017:
我是第1個進程,結束時間是Sun Oct 22 19:22:37 2017
我是第2個進程,結束時間是Sun Oct 22 19:22:39 2017
我是第3個進程,結束時間是Sun Oct 22 19:22:41 2017
我是第4個進程,結束時間是Sun Oct 22 19:22:43 2017
我是第4個進程：結束前進程5的狀態是： True        #可以看到，此時線程5還是存活的，但4結束后5就消失了。

最后一種應用時，我們希望主程序等待某幾個子線程先執行完后在運行，并且殺死剩余沒有完成的程序，可以用setDaemon()、join() 組合的方式：
如：完整運行完第1,2,3線程，之后運行主線程，主線程完成后殺死剩余的子線程：

def fuction(i):
    print("我是第%s個進程,開始時間是%s"%(i+1,time.ctime()))
    time.sleep((i+0.5)*2)               #模擬子程序運行隨機秒
    print("我是第%s個進程,結束時間是%s"%(i+1,time.ctime()))
    if i ==3:
        print("我是第4個進程：結束前進程5的狀態是：" ,threads[4].is_alive())
threads=[threading.Thread(target=fuction,args=(i,) ) for i in range(5)]

#threads[0].setDaemon(True)
#threads[1].setDaemon(True)
#threads[2].setDaemon(True)
threads[3].setDaemon(True)          #設置第4和5子線程為可以kill的線程
threads[4].setDaemon(True)

for t in threads:
    t.start()
threads[0].join()                  #設置第1,2,3線程阻塞主線程的子線程
threads[1].join()
threads[2].join()
print("主進程：%s:"%(time.ctime()))

#輸出--------------------------
我是第1個進程,開始時間是Sun Oct 22 19:32:24 2017
我是第2個進程,開始時間是Sun Oct 22 19:32:24 2017
我是第3個進程,開始時間是Sun Oct 22 19:32:24 2017
我是第4個進程,開始時間是Sun Oct 22 19:32:24 2017
我是第5個進程,開始時間是Sun Oct 22 19:32:24 2017
我是第1個進程,結束時間是Sun Oct 22 19:32:25 2017
我是第2個進程,結束時間是Sun Oct 22 19:32:27 2017
我是第3個進程,結束時間是Sun Oct 22 19:32:29 2017
主進程：Sun Oct 22 19:32:29 2017:                #我們可以看到只完成了第1,2,3線程，然后最后是主線程

這篇文章就到這里，python中子線程的暫停，阻塞，關閉，和喚醒，本人都不是很明確，如有好方法希望大家一起交流。我先寫在這里。對于tensorflow中的讀取數據線程控制，等我整理在下一篇博客。

云服務器 GPU云服務器實現多線程多線程實現 php實現多線程 android實現多線程

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/40938.html

淺談Python多線程

摘要：進程可創建多個線程來執行同一程序的不同部分。就緒等待線程調度。運行線程正常運行阻塞暫停運行，解除阻塞后進入狀態重新等待調度。消亡線程方法執行完畢返回或者異常終止。多線程多的情況下，依次執行各線程的方法，前頭一個結束了才能執行后面一個。淺談Python多線程作者簡介: 姓名:黃志成(小黃)博客: 博客線程一.什么是線程? 操作系統原理相關的書，基本都會提到一句很經典的話：進程...

zsirfs 2019-07-30 16:07 評論0 收藏0
Python多線程

摘要：多線程的理解多進程和多線程都可以執行多個任務，線程是進程的一部分。多線程創建在中，同樣可以實現多線程，有兩個標準模塊和，不過我們主要使用更高級的模塊。多線程的應用場景。 1、多線程的理解多進程和多線程都可以執行多個任務，線程是進程的一部分。線程的特點是線程之間可以共享內存和變量，資源消耗少（不過在Unix環境中，多進程和多線程資源調度消耗差距不明顯，Unix調度較快），缺點是線程之間...

dcr309duan 2019-07-30 15:05 評論0 收藏0
python大佬養成計劃----進程、線程與多進程

摘要：在一個進程內部，要同時干多件事，就需要同時運行多個子任務，我們把進程內的這些子任務稱為線程。總結一下，多任務的實現方式有三種多進程模式多線程模式多進程多線程模式線程是最小的執行單元，而進程由至少一個線程組成。進程與線程很多同學都聽說過，現代操作系統比如Mac OS X，UNIX，Linux，Windows等，都是支持多任務的操作系統。什么叫多任務呢？簡單地說，就是操作系統可以同時...

taowen 2019-07-30 17:49 評論0 收藏0
python學習筆記- 多線程

摘要：也提供多線程支持，而且中的線程并非是模擬出來的多線程，而是系統級別的標準庫提供了兩個模塊和。同一個變量，線程則會互相共享。例如多個線程對銀行中的某一個賬戶進行操作。但是實際情況是隨意切換線程。說到的多線程編程，就會繞不過。該文章參考了http://www.liaoxuefeng.com/wi... 廖雪峰的教程。一個進程至少有一個線程。Python也提供多線程支持，而且Python...

RiverLi 2019-07-25 11:23 評論0 收藏0
Python協程（真才實學，想學的進來）

摘要：所以與多線程相比，線程的數量越多，協程性能的優勢越明顯。值得一提的是，在此過程中，只有一個線程在執行，因此這與多線程的概念是不一樣的。真正有知識的人的成長過程，就像麥穗的成長過程：麥穗空的時候，麥子長得很快，麥穗驕傲地高高昂起，但是，麥穗成熟飽滿時，它們開始謙虛，垂下麥芒。 ——蒙田《蒙田隨筆全集》上篇論述了關于python多線程是否是雞肋的問題，得到了一些網友的認可，當然也有...

lykops 2019-07-30 16:55 評論0 收藏0
通過網絡圖片小爬蟲對比Python中單線程與多線（進）程的效率

摘要：批評的人通常都會說的多線程編程太困難了，眾所周知的全局解釋器鎖，或稱使得多個線程的代碼無法同時運行。多線程起步首先讓我們來創建一個名為的模塊。多進程可能比多線程更易使用，但需要消耗更大的內存。批評 Python 的人通常都會說 Python 的多線程編程太困難了，眾所周知的全局解釋器鎖（Global Interpreter Lock，或稱 GIL）使得多個線程的 Python 代碼無...

W4n9Hu1 2019-07-31 12:22 評論0 收藏0