2. 程式人生 > >【python】Threading快速使用和執行緒鎖的理解及.join()用法詳說

【python】Threading快速使用和執行緒鎖的理解及.join()用法詳說

阿新 • • 發佈：2019-01-27

0X0:在開始之前先理解一下threading的意義，我們知道寫一個程式，之後程式執行完畢，得到想要的結果。這就是我對一個軟體的理解。
那麼有時候就出現了一個問題，如果這個程式在執行過程中要實現多個功能，即先執行第一個功能，同時執行第二個功能，最後執行第三個功能，python為我們提供threading庫來為我們服務。

0X1:如果你對我剛才說的執行一二三個程式沒有理解，就這麼說吧，你的python程式中有三個函式，你要先執行第一個同時執行第二個，最後執行第三個。當然你可以直接一個一個的啟動，但是這樣會浪費不少的時間，而且當其中一個函數出錯了你還要在原始碼新增except來捕獲異常來處理，所以得不償失，合理的使用threading就能避免這個問題。

1X1:下面我通過程式碼來展示threading的使用，先看第一個，第一個是threading的常規使用辦法，我會在原始碼添加註釋方便大家閱讀

# -*- coding: utf-8 -*-
"""
__author__ = 'Langziyanqin'
__QQ__ = '982722261'
              ┏┓      ┏┓
            ┏┛┻━━━┛┻┓
            ┃      ☃      ┃
            ┃  ┳┛  ┗┳  ┃
            ┃      ┻      ┃
            ┗━┓      ┏━┛
                ┃      ┗━━━┓
                ┃  神獸保佑    ┣┓
                ┃　永無BUG！   ┏┛
                ┗┓┓┏━┳┓┏┛
                  ┃┫┫  ┃┫┫
                  ┗┻┛  ┗┻┛
"""
 

import sys
import threading
import Queue
import time
reload(sys)
sys.setdefaultencoding('utf-8')
q = Queue.Queue()
def loop():   #定義一個要迴圈的函式，當然後面肯定會定義好幾個函式
    print 'thread %s is running...' % threading.current_thread().name
    #threading.current_thread().name就是當前執行緒的名字  可以在第35行中看到  可以自定義子執行緒的名字
    n = 0
 

    while n < 10:
        n = n + 1
        print '%s >>> %s' % (threading.current_thread().name, n)
        #輸出當前執行緒名字  和迴圈的引數n
    print 'thread %s ended.' % threading.current_thread().name
print 'thread %s is running...' % threading.current_thread().name

#下面的一部分就是threading的核心用法
t = threading.Thread(target=loop) #包括target name args 之類的 一般我只用targer=你定義的函式名
#t = threading.Thread(target=loop, name='當前執行緒為:')
t.start() #開始
t.join()  #關於join的相關資訊我會在後面的程式碼詳說
print 'thread %s ended.' % threading.current_thread().name

執行結果

F:\Python27\python.exe "E:/python27/python study/threading1.py"
thread MainThread is running...
thread Thread-1 is running...
Thread-1 >>> 1
Thread-1 >>> 2
Thread-1 >>> 3
Thread-1 >>> 4
Thread-1 >>> 5
Thread-1 >>> 6
Thread-1 >>> 7
Thread-1 >>> 8
Thread-1 >>> 9
Thread-1 >>> 10
thread Thread-1 ended.
thread MainThread ended.

程序已結束,退出程式碼0

你也可以在#t = threading.Thread(target=loop, name=’當前執行緒為:’) 設定成自己的名字
當然你要先把註釋符去掉，並且在上一行加入註釋符，這樣只是讓大家更直觀的看到使用方法。

1X2:既然常規的使用方法已說完，接下來說說進階的，如果一個程式有兩個函式要執行，常規的載入使用辦法為

# -*- coding: utf-8 -*-
"""
__author__ = 'Langziyanqin'
__QQ__ = '982722261'
              ┏┓      ┏┓
            ┏┛┻━━━┛┻┓
            ┃      ☃      ┃
            ┃  ┳┛  ┗┳  ┃
            ┃      ┻      ┃
            ┗━┓      ┏━┛
                ┃      ┗━━━┓
                ┃  神獸保佑    ┣┓
                ┃　永無BUG！   ┏┛
                ┗┓┓┏━┳┓┏┛
                  ┃┫┫  ┃┫┫
                  ┗┻┛  ┗┻┛
"""
import sys
import threading
import time
import Queue
reload(sys)
sys.setdefaultencoding('utf-8')
t00 = time.time()
def cs1():
    time0 = time.time()
    for x in range(5):
        print x + time.time()-time0 #+ threading.current_thread().name
        print threading.current_thread().name


def cs2():
    for x1 in range(6,9):
        print x1
        time.sleep(0.5)
        print threading.current_thread().name


threads=[]

t1 = threading.Thread(target=cs1)#,name='當先現場:')
t2 = threading.Thread(target=cs2)
threads.append(t1)
threads.append(t2)
for x in threads:
    x.start()
#x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
    x.join()  #執行緒堵塞 先執行第一個在執行第二個
print 'use time.{}'.format(time.time()-t00)

其實就是新建一個列表，把兩個程序載入進去，然後迭代使用一遍，關於join，大家看下注釋就能明白，join在不同的地方作用也不同，那麼我們看看下面這樣會使用多少時間呢

for x in threads:
    x.start()
    x.join()  #執行緒堵塞 先執行第一個在執行第二個
print 'use time.{}'.format(time.time()-t00)

執行結果

F:\Python27\python.exe "E:/python27/python study/threading2.py"
0.0
Thread-1
1.0
Thread-1
2.0
Thread-1
3.0
Thread-1
4.0
Thread-1
6
Thread-2
7
Thread-2
8
Thread-2
use time.1.50099992752

程序已結束,退出程式碼0

可以看到是先把第一個函式執行完畢在執行第二個函式那麼試一下下面使用的時間

for x in threads:
    x.start()
x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
print 'use time.{}'.format(time.time()-t00)
F:\Python27\python.exe "E:/python27/python study/threading2.py"
0.0
Thread-1
1.0
Thread-16

2.0
Thread-1
3.0
Thread-1
4.0
Thread-1
Thread-2
7
Thread-2
8
Thread-2
use time.1.50200009346

程序已結束,退出程式碼0

這裡可以明顯直觀的看到，輸出的結果混亂（同時執行，同時輸出）兩個函式是同時執行的。而且用的時間一樣，如果把函式其中的time.sleep(0.5)去掉之後看看效果

for x in threads:
    x.start()
#x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
    x.join()  #執行緒堵塞 先執行第一個在執行第二個
print 'use time.{}'.format(time.time()-t00)
F:\Python27\python.exe "E:/python27/python study/threading2.py"
0.0
Thread-1
1.00100016594
Thread-1
2.00100016594
Thread-1
3.00100016594
Thread-1
4.00100016594
Thread-1
6
Thread-2
7
Thread-2
8
Thread-2
use time.0.00100016593933

程序已結束,退出程式碼0

第二個

for x in threads:
    x.start()
x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
    #x.join()  #執行緒堵塞 先執行第一個在執行第二個
print 'use time.{}'.format(time.time()-t00)
F:\Python27\python.exe "E:/python27/python study/threading2.py"
0.0
Thread-1
1.0
Thread-16

2.00099992752Thread-2

Thread-17

3.00099992752
 Thread-1Thread-2

4.000999927528

Thread-1Thread-2

use time.0.000999927520752

程序已結束,退出程式碼0

1X3:可以看到第二個用的時間少一些，因為只是輕微的計算量所以時間上看不出什麼太大的區別，當你的函式更加複雜的時候，就能看到這兩者的區別了。
大家有沒有發現，我在兩個函式中第一個函式迭代的變數是x 第二個迭代的變數是x1，這是為什麼呢？
因為啊，主執行緒中兩個子執行緒都是共享變數的，所以如果兩個函式迭代的都是x，那麼會出現什麼效果呢？
看看演示：
修改原始碼，統一變數x：

# -*- coding: utf-8 -*-
"""
__author__ = 'Langziyanqin'
__QQ__ = '982722261'
              ┏┓      ┏┓
            ┏┛┻━━━┛┻┓
            ┃      ☃      ┃
            ┃  ┳┛  ┗┳  ┃
            ┃      ┻      ┃
            ┗━┓      ┏━┛
                ┃      ┗━━━┓
                ┃  神獸保佑    ┣┓
                ┃　永無BUG！   ┏┛
                ┗┓┓┏━┳┓┏┛
                  ┃┫┫  ┃┫┫
                  ┗┻┛  ┗┻┛
"""
import sys
import threading
import time
import Queue
reload(sys)
sys.setdefaultencoding('utf-8')
t00 = time.time()
def cs1():
    time0 = time.time()
    for x in range(9):
        print x + time.time()-time0 #+ threading.current_thread().name
        print threading.current_thread().name


def cs2():
    for x in range(6,9):
        print x
        #time.sleep(0.5)
        print threading.current_thread().name


threads=[]

t1 = threading.Thread(target=cs1)#,name='當先現場:')
t2 = threading.Thread(target=cs2)
threads.append(t1)
threads.append(t2)
for x in threads:
    x.start()
x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
    #x.join()  #執行緒堵塞 先執行第一個在執行第二個
print 'use time.{}'.format(time.time()-t00)

執行結果：

F:\Python27\python.exe "E:/python27/python study/threading2.py"
0.0
Thread-1
1.0
Thread-1
2.0
Thread-1
3.0
Thread-1
4.0
Thread-1
5.0
Thread-1
 6.06

Thread-1Thread-2

7.07

Thread-1Thread-2

8.08

Thread-1Thread-2

use time.0.000999927520752

程序已結束,退出程式碼0

可以看到同時執行的時候變數被改變了。
接下來我要說的就是threading的執行緒鎖，防止在執行過程中第一個子執行緒改變第二個子執行緒中函式的變數。
threading為我們提供了lock的方法。

1X4:使用方法其實很簡單，大家看一看下面的程式碼就這怎麼用了。

# -*- coding: utf-8 -*-
"""
__author__ = 'Langziyanqin'
__QQ__ = '982722261'
              ┏┓      ┏┓
            ┏┛┻━━━┛┻┓
            ┃      ☃      ┃
            ┃  ┳┛  ┗┳  ┃
            ┃      ┻      ┃
            ┗━┓      ┏━┛
                ┃      ┗━━━┓
                ┃  神獸保佑    ┣┓
                ┃　永無BUG！   ┏┛
                ┗┓┓┏━┳┓┏┛
                  ┃┫┫  ┃┫┫
                  ┗┻┛  ┗┻┛
"""
import sys
import threading
import time
reload(sys)
sys.setdefaultencoding('utf-8')
l = threading.Lock()
t00 = time.time()
def cs1():
    l.acquire()
    time0 = time.time()
    for x in range(5):
        print x + time.time()-time0 #+ threading.current_thread().name
        print threading.current_thread().name
    #finally:
    l.release()


def cs2():
    l.acquire()
    for x in range(6,9):
        print x
        #time.sleep(0.5)
        print threading.current_thread().name
    l.release()


threads=[]

t1 = threading.Thread(target=cs1)#,name='當先現場:')
t2 = threading.Thread(target=cs2)
threads.append(t1)
threads.append(t2)
for x in threads:
    x.start()
x.join()   #執行緒不堵塞  但是會出現不勻稱的表現  並且會修改不同執行緒中的變數
print 'use time{}'.format(time.time()-t00)

執行結果：

F:\Python27\python.exe "E:/python27/python study/threading3.py"
0.0
Thread-1
1.0
Thread-1
2.0
Thread-1
3.0
Thread-1
4.0
Thread-1
6
Thread-2
7
Thread-2
8
Thread-2
use time0.0

程序已結束,退出程式碼0

…….

相關推薦

【python】Threading快速使用和執行緒鎖的理解及.join()用法詳說

0X0:在開始之前先理解一下threading的意義，我們知道寫一個程式，之後程式執行完畢，得到想要的結果。這就是我對一個軟體的理解。 那麼有時候就出現了一個問題，如果這個程式在執行過程中要實現多個功能，即先執行第一個功能，同時執行第二個功能，最後執行第三個功

【Linux】GDB除錯多執行緒和多程序以及Core檔案

GDB偵錯程式 基本概念 GDB是GNU開源組織釋出的一個強大的UNIX下的程式除錯工具。或許，各位比較喜歡那種圖形介面方式的，像VC、BCB等IDE的除錯，但如果你是在UNIX平臺下做軟體，你會發現

【Python】創建和使用類

自動運行 over 多個實例 引用 bottom color ack 小寫 運行 面向對象編程是最有效的軟件編寫方法之一 創建Dog類 class Dog(): ‘‘‘一次模擬小狗的簡單測試‘‘‘ def __init__(self,name,age

【Python】使用類和實例

mil 三種 mod 特定 scribe car pad 指定 () Car類 class Car(): ‘‘‘模擬汽車‘‘‘ def __init__(self,name,model,year): ‘‘‘初始化汽車的屬性‘‘‘

【轉】面向物件 -多執行緒 理論知識

1. 基本概念 程序： 系統中正在執行的程式。 一條程序就代表當前系統中正在執行的一個程式。 每個程序都是相互獨立的，每個程序中都有屬於自己的記憶體空間。 執行緒：一個程序想要執行任務，必須通過執行緒來排程（執行），每個程序至少要有一個執行緒，如果沒有執行緒，那麼該程序（程式）就會退出執行。 執

【python】關於excel和shp的使用在matplotlib

關於excel和shp的使用在matplotlib 使用pandas 對excel進行簡單操作 使用cartopy 讀取shpfile 展示到matplotlib中 利用shpfile檔案中的一些欄位進行一些著色處理 #!/usr/bin/env pyt

python中的程序和執行緒

什麼是程序(process)？ 程式並不能單獨執行，只有將程式裝載到記憶體中，系統為它分配資源才能執行，而這種執行的程式就稱之為程序。程式和程序的區別就在於：程式是指令的集合，它是程序執行的靜態描述文字；程序是程式的一次執行活動，屬於動態概念。 在多道程式設計中，我們允許多個程式

【python】Pycharm安裝和使用

1. Pycharm安裝 去Pycharm官網或者直接輸入網址：jetbrains.com/pycharm/download，下載安裝包。 把Pycharm安裝包解壓到桌面上（這裡解壓路徑自己決定） cd /home/kiosk/Desktop/pycharm-co

【總結】53道JAVA執行緒面試題

1) 什麼是執行緒？ 執行緒是作業系統能夠進行運算排程的最小單位，它被包含在程序之中，是程序中的實際運作單位。程式設計師可以通過它進行多處理器程式設計，你可以使用多執行緒對運算密集型任務提速。比如，如果一個執行緒完成一個任務要100毫秒，那麼用十個執行緒完成改任務只需10毫秒。Java在語言層面

Python使用裝飾器和執行緒限制函式執行時間的方法

前言：   （不想看廢話的可以直接copy尾部的程式碼）   在八月上旬的時候，曾經寫過一個多執行緒爬蟲。程式在執行時經常莫名的卡死。這令我很是費解，後來才發現，是在請求對方資源時，伺服器長時間未返回完資料。導致IO阻塞。   其實不只是爬蟲，很多時候一個函式很可能因為某種不可預知的事情，而有時很可能會卡

【原創】技術系列之 執行緒（一）

作者：CppExplore 網址：http://www.cppblog.com/CppExplore/廢話不多說，詳細介紹使用執行緒的優點好處請參考baidu、google。一、執行緒使用場景。使用執行緒的方式大致有兩種：（1）流水線方式。根據業務特點，將一個流程的處理分割成多個執行緒，形成流水線的處

【Python】基礎-繼承和派生

     面向物件的程式設計帶來的主要好處之一是程式碼的複用，實現這種複用的方法之一是通過繼承機制。     python中解決程式碼複用的方式：繼承和組合。1 什麼是繼承     繼承是一種建立類的方法，在python中，一個類可以繼承來自一個或多個父類。原始類稱為基類或超類。class ParentCla

【python 】資料型別和返回資料型別的函式

字串+字串 →稱為 "拼接"   數字+數字 →稱為"加法運算" 一、資料型別：整型、浮點型、布林型別 1、整型：整數 注意：python2中長整型需要在後面加l，python3中不區分整型和長整

【Python】numpy快速入門

1、基本概念 numpy的主要內容是齊次多維陣列，是一張表，元素型別相同，通常是數字，索引為一個正整數構成的元組。在numpy中，陣列的維叫做axes，axes的個數叫做rank。例如，[1,2,1]是3D空間中的一個座標點，作為陣列，它是一維的，有一個axe

【Python】工廠模式和建造者模式的區別

最近在看《精通Python設計模式（Mastering Python Design patterns）》， 剛剛看完建造者模式，由於和看完工廠模式隔的時間有點久，再加上兩者本來就很像，有點分不清了。 所以，今天又看了看這兩者，區分一下，加強下記憶，以便安心看後邊的設計模式

Python學習筆記（14）-Python中的程序和執行緒

1.多程序 1.1建立程序 Unix/Linux/Mac作業系統都可以使用fork()函式來建立子程序，分別在父程序和子程序內返回，例如 程式碼: import os # 匯入os模組 print ('當前程序的ID是：%s' % os.g

52.[Python]使用threading進行多執行緒程式設計

基礎知識 使用Python進行多程序程式設計歡迎參考我的前一篇部落格，本文介紹的threading模組在我的github專案上有對應的原始碼，歡迎閱讀時參考。 程序是資源的擁有者，程序的建立、切換和銷燬代價較高，所以引入了輕量程序——執行緒。 執

【JavaScript】JavaScript是多執行緒還是單執行緒？

　　之前在學瀏覽器渲染流程時瞭解的JavaScript是單執行緒執行的，時不時要考慮瀏覽器執行緒阻塞問題，然而又有人說JavaScript可以非同步執行，比如setInterval、setTimeout以及Ajax等。那究竟是單執行緒還是多執行緒呢？ 　　下

【CountDownLatch】實現多個執行緒同時啟動

要點： 1、 CountDownLatch的計數是1. 2、await發生在多個子執行緒，主執行緒負責countDown，相當於管理多個執行緒的同步時機。 package multithread; import java.util.HashMap; import jav

Chrome原始碼剖析 【一】 Chrome的多執行緒模型

【一】 Chrome的多執行緒模型 0. Chrome的併發模型 如果你仔細看了前面的圖，對Chrome的執行緒和程序框架應該有了個基本的瞭解。Chrome有一個主程序，稱為Browser程序，它是老大，管理Chrome大部分的日常事務；其次，會有很多Rendere