2. 程式人生 > >python大佬養成計劃----執行緒與多執行緒

python大佬養成計劃----執行緒與多執行緒

阿新 • • 發佈：2018-12-10

建立執行緒

一個程序必有一個執行緒，程序也可由多個執行緒組成，但有一個執行緒為主執行緒。若一個任務需要花10Mins，當只有一個執行緒時，花費10Mins,當有十個執行緒時，可能就花費1Mins,所以多執行緒可以提升任務執行時間，提高工作效率。python裡與執行緒有關的模組：

  • _thread 底層
  • threading

檢視當前執行的執行緒個數：threading.current_thread()檢視當前執行緒資訊：threading.active_count()

import _thread
import threading

def job():

    print("當前執行緒個數：",threading.active_count())
    print("當前執行緒資訊",threading.current_thread())

if __name__=='__main__':
    job()

圖片描述

_thread建立多執行緒

呼叫thread模組中的start_new_thread()函式來產生新執行緒。thread.start_new_thread(function,args = ())

#_thread建立多執行緒
import _thread
import time

def job(name):
    print("name:%s,time:%s" %(name,time.ctime()))

if __name__=="__main__":
    # 建立多個執行緒, 但是沒有開始執行任務
    _thread.start_new_thread(job,('thread1',))
    _thread.start_new_thread(job,('thread2',))
    while True: #盲等待
        pass

圖片描述

threading通過例項化Thread類建立多執行緒

_thread模組提供了低級別的、原始的執行緒以及一個簡單的鎖。threading模組是對_thread再封裝，對使用者更友好通過例項化Thread物件建立執行緒，Thread的方法有：

  • run() #Method representing the thread's activity.
  • start() #Start the thread's activity.
  • join() #Wait until the thread terminates.
  • is_alive() #Return whether the thread is alive.
import threading

def job(name):
    print("當前執行的任務名：",name)
    print("當前執行緒個數：",threading.active_count())
    print("當前執行緒資訊：",threading.current_thread())

if __name__=="__main__":
    t1 = threading.Thread(target=job,name='thread1',args=('job1',))
    t2 = threading.Thread(target=job,name='thread2',args=('job2',))
    t1.start()  #Start the thread's activity.
    t2.start()

圖片描述

使用多執行緒與不使用多執行緒的對比

不使用多執行緒執行任務，程式會一直等待sleep時間過去，在執行下一條命令。

#不使用多執行緒
import time

def music(name):
    for i in range(2):
        print("i am listening :",name)
        time.sleep(2)
def read(book):
    for i in range(2):
        print("i am reading :",book)
        time.sleep(1)
if __name__ == '__main__':
    start_time = time.time()
    music("空空如也")
    read('面紗')
    print("花費時間: %s" %(time.time()-start_time))

圖片描述

使用多執行緒執行任務，在遇到某一執行緒需要等待時，會執行其他執行緒Thread.join()會等待當前執行緒執行結束，再執行主執行緒。

import threading
import time


def music(name):
    for i in range(2):
        print("i am listening :",name)
        time.sleep(2)
def read(book):
    for i in range(2):
        print("i am reading :",book)
        time.sleep(1)
if __name__=="__main__":
    start_time = time.time()
    t1 = threading.Thread(target=music,args=('空空如也',))
    t2 = threading.Thread(target=read,args=('面紗',))
    t1.start()
    t2.start()
    t1.join()   #等待執行緒執行結束，才執行主程式，防止主執行緒阻塞子執行緒
    t2.join()
    end_time = time.time()
    print("任務執行時間：",end_time-start_time)

圖片描述

守護執行緒setDeamon

當申明一個子執行緒為守護執行緒時，主執行緒結束時，子執行緒也結束。申明守護執行緒需要在開啟執行緒之前。

import threading
import time

def music(name):
    for i in range(2):
        print("listening music :",name)
        time.sleep(4)

def code(pro):
    for i in range(2):
        print('i am coding :',pro)
        time.sleep(5)

if __name__=='__main__':
    st_time = time.time()
    t1 = threading.Thread(target=music,args=('hello',))
    t2 = threading.Thread(target=code,args=('mydiff',))
    #將執行緒申明為守護執行緒，如果設定為True，當主執行緒結束，子執行緒也結束
    #必須在啟動執行緒之前進行設定
    t1.setDaemon(True)
    t2.setDaemon(True)  #主執行緒執行結束之後，子執行緒還沒來得及執行結束，整個程式就退出了
    t1.start()
    t2.start()
    end_time = time.time()
    print('執行時間:',end_time-st_time)

圖片描述

執行緒同步

如果多個執行緒共同對某個資料修改，則可能出現不可預料的結果，為了保證資料的正確性，需要對多個執行緒進行同步。 使用Thread物件的Lock和Rlock可以實現簡單的執行緒同步，這兩個物件都有acquire方法和release方法，對於那些需要每次只允許一個執行緒操作的資料，可以將其操作放到acquire和release方法之間。

import threading

def add(lock):
    #操作變數之前加鎖
    lock.acquire()
    global money
    for i in range(1389993):
        money+=1
    #變數操作完成之後，解鎖
    lock.release()

def reduce(lock):
    #操作變數之前加鎖
    lock.acquire()
    global money
    for i in range(4728937):
        money-=1
    #變數操作完成之後，解鎖
    lock.release()

if __name__=="__main__":
    money = 0
    lock = threading.Lock() #示例化一個鎖物件
    t1 = threading.Thread(target=add,args=(lock,))
    t2 = threading.Thread(target=reduce,args=(lock,))
    t1.start()
    t2.start()

    t1.join()
    t2.join()
    print('最終金額為：',money)

圖片描述

GIL全域性直譯器鎖

Python 程式碼的執行由 Python 虛擬機器(也叫直譯器主迴圈)來控制。Python 在設計之初就考慮到要在主迴圈中，同時只有一個執行緒在執行，就像單 CPU 的系統中執行多個程序那樣，記憶體中可以存放多個程式，但任意時刻，只有一個程式在 CPU 中執行。同樣地，雖然 Python 直譯器中可以“執行”，多個執行緒，但在任意時刻，只有一個執行緒在直譯器中執行。

對 Python 虛擬機器的訪問由全域性直譯器鎖（GIL）來控制，正是這個鎖能保證同一時刻只有一個執行緒在執行。

執行過程:

1). 設定GIL
2). 切換到執行緒去執行對應的任務;
3). 執行
    - 執行完了
    - time.sleep()
    - 獲取其他資訊才能繼續執行, eg: 從網路上獲取網頁資訊等;
3. 把執行緒設定為睡眠狀態
4. 解鎖GIL
5.再次重複執行上述內容;

生產者消費者模型

在工作中，某些模組生成一些資料，由另一些模組負責處理。產生資料的模組，就形象地稱為生產者；而處理資料的模組，就稱為消費者。在生產者與消費者之間在加個緩衝區，我們形象的稱之為倉庫，生產者負責往倉庫了進商品，而消費者負責從倉庫裡拿商品，這就構成了生產者消費者模式。這裡，我們用生產者消費者模型來實現多執行緒的網址訪問，節省時間。

#多執行緒實現生產者消費者模型
#實現不同的網址或ip訪問
import threading
from urllib.request import urlopen


def create_data():
    with open('ips.txt','w') as f:
        f.write("www.baidu.com\n")
        f.write("www.163.com\n")
        for i in range(100):
            f.write('172.25.254.%s\n' %(i+1))
def creat_url(filename='ips.txt'):
    ports=[80,443]
    with open(filename) as f:
        ips = [url_info.strip() for url_info in f.readlines()]
    urls = ['http://%s:%s' %(ip,port) for ip in ips for port in ports]
    return urls

def job(url):
    try:
        urlObj = urlopen(url)
    except Exception as e :
        print('Warnning!!!    %s不可訪問' %(url))
    else:
        print("%s可以訪問" %(url))

if __name__=="__main__":
    urls = creat_url()
    threads = []
    for url in urls:
        t = threading.Thread(target=job,args=(url,))
        threads.append(t)
        t.start()
    [thread.join() for thread in threads]
    print("任務執行結束")

圖片描述

再封裝threading.Thread類

無參版

對threading.Thread類的再封裝，執行時無需傳遞引數

from threading import Thread
class IpThread(Thread):
    def __init__(self):
        super(IpThread, self).__init__()
# 將多執行緒需要執行的任務重寫到run方法中;
    def run(self):
        print("this is a JOB")
        print(type(self))

t = IpThread()
t.start()

圖片描述

含參版

實現訪問Ip地址

import json
from threading import Thread
from urllib.request import urlopen

class IpThread(Thread):
    #重寫構造方法，如果執行的任務需要傳遞引數，那將引數與self繫結
    def __init__(self,jobname,ip):
        super(IpThread, self).__init__()
        self.jobname = jobname
        self.ip = ip
    #將多執行緒需要執行的任務重寫到run方法中
    def run(self):
        print('this is a %s job' %(self.jobname))
        #需要有一個引數，傳遞ip
        url = "http://ip.taobao.com/service/getIpInfo.php?ip=%s" % (self.ip)
        try :
            # 根據url獲取網頁的內容， 並且解碼為utf-8格式， 識別中文;
            result = urlopen(url).read().decode('utf-8')
        except Exception as e:
            print("訪問%s失敗" %(self.ip))
        else:
             # 將獲取的字串型別轉換為字典， 方便處理
            d = json.loads(result)['data']
            country = d['country']
            city = d['city']
        print("%s位於%s,城市為%s" %(self.ip,country,city))

if __name__=="__main__":
    ips = ['172.25.254.22','8.8.8.8','89.31.136.0']
    threads = []
    for ip in ips :
        t = IpThread(jobname='Clawer',ip=ip)
        threads.append(t)
        t.start()
    [thread.join() for thread in threads]
    print("程式執行結束")

圖片描述

相關推薦

python大佬養成計劃----執行緒與多執行緒

建立執行緒 一個程序必有一個執行緒，程序也可由多個執行緒組成，但有一個執行緒為主執行緒。若一個任務需要花10Mins，當只有一個執行緒時，花費10Mins,當有十個執行緒時，可能就花費1Mins,所以多執行緒可以提升任務執行時間，提高工作效率。python裡與執行緒

python大佬養成計劃----paramiko實現SSH

paramiko模組 SSH 為 Secure Shell 的縮寫，由 IETF 的網路小組（Network Working Group）所制定；SSH 為建立在應用層基礎上的安全協議。SSH 是目前較可靠，專為遠端登入會話和其他網路服務提供安全性的協議。利用 SS

python大佬養成計劃----分散式程序

分散式程序 在Thread和Process中，應當優選Process，因為Process更穩定，而且，Process可以分佈到多臺機器上，而Thread最多隻能分佈到同一臺機器的多個CPU上。 Python的 multiprocessing 模組不但支援多程序， 其

python大佬養成計劃-----多程序

程序 Python是執行在直譯器中的語言，查詢資料知道，python中有一個全域性鎖（GIL），在使用多程序(Thread)的情況下，不能發揮多核的優勢。而使用多程序(Multiprocess)，則可以發揮多核的優勢真正地提高效率。如果多執行緒的程序是CPU密集型的

程序、執行緒與多執行緒

一、說說概念 1、程序（process） 狹義定義：程序就是一段程式的執行過程。 廣義定義：程序是一個具有一定獨立功能的程式關於某個資料集合的一次執行活動。它是作業系統動態執行的基本單元，在傳統的作業系統中，程序既是基本的分配單元，也是基本的執行單元。 簡單的來講程序的概念主

MySQL---當Java遇上MySQL⑤---單執行緒與多執行緒下的事務

事務transaction 原子性(atomicity)：組成事務處理的語句形成了一個邏輯單元，不能只執行其中的一部分。 一致性(consistency)：在事務處理執行前後，資料庫是一致的(資料庫資料完整性約束)。 隔離性(isolcation)：一個事務處理對另

序列化與反序列化，執行緒與多執行緒。

一、序列化 屬性類 public class FlyPig implements Serializable { private static String age = "269"; private S

泥瓦匠聊併發程式設計：執行緒與多執行緒必知必會（基礎篇）

本文目錄 執行緒與多執行緒 執行緒的執行與建立 執行緒的狀態 1 執行緒與多執行緒 執行緒是什麼？ 執行緒（Thread）是一個物件（Object）。用來幹什麼？Java 執行緒（也稱 JVM 執行緒）是 Java 程序內允許多個同時進行的任務。該程序內併發的任務成為執行緒（Thread）

執行緒與多執行緒（四）——執行緒排程

四、執行緒排程   執行緒排程管理器負責執行緒排隊和CPU線上程間的分配，並按執行緒排程演算法進行排程。當執行緒排程管理器選中某個執行緒時，該執行緒獲得 CPU資源進人執行狀態。   執行緒排程是搶佔式排程，即如果在當前執行緒執行過程中個更高優先順序的執行緒

.NET Framework中定時器timer的單執行緒與多執行緒使用講解

如果你需要使用規律的時間間隔重複執行一些方法，最簡單的方式是使用定時器（timer）。與下邊的例子相比，定時器可以便捷、高效地使用記憶體和資源： ? 1 2 3 4 5 6 7 new Thread (delegate() { while (enabled)

JAVA執行緒與多執行緒

去安卓面試的時候通常會問一些java問題，所以呢你可能覺得答問題時答案很蛋疼，今天來介紹一下執行緒。 先看幾個概念： 執行緒：程序中負責程式執行的執行單元。一個程序中至少有一個執行緒。 多執行緒：解決多工同時執行的需求，合理使用CPU資源。多執行緒的執

多執行緒使用之主執行緒與多執行緒響應同步

需求： 匯出資料10000條資料到excel表中。希望用多執行緒優化匯出速度。 設計： 將10000條資料分成10份。用10個執行緒分別給excel寫值分10個sheet頁 問題： 匯出資料時，由於寫值啟動了多執行緒，匯出資料為空excel表格 問題的梳理： 由於

程序、執行緒與多執行緒概念詳解

一、概述 在windows中，每一個開啟執行的應用程式或後臺程式，比如執行中的QQ、谷歌瀏覽器、網易雲音樂、資源管理器等都是一個程序。我們感覺這些程式是“同時”執行的，但實際上，一個處理器同一時刻只能執行一個程序，只是CPU在高速輪換執行讓我們有這樣的錯覺，我

python多執行緒————8、多執行緒與多程序對比

#多程序程式設計 #耗cpu的操作，用多程序程式設計，對於io操作來說，使用多執行緒程式設計，程序切換代價要高於執行緒 import time from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor,as_compl

Python佇列與多執行緒及檔案鎖

佇列實現生產-多執行緒消費 先看程式碼 # -*- coding: utf-8 -*- import queue import threading mu = threading.Lock() class Producer(threading.Thread): def __init__(

python中多執行緒與多程序的選擇問題

多執行緒與多程序的選擇問題 既然python中多執行緒和多程序都能夠進行非同步操作,那麼到底應該如何選擇 首先我們必須知道GIL全域性解釋鎖對執行緒的影響,其同一時間只能夠允許一個執行緒進入cpu進行執行,因此對於cpu密集型的程式並不適用於多執行緒操作 cpu密集型的功能對cp

多執行緒與多程序及Python實現【理論部分】

計算機的核心是CPU，它承擔了所有的計算任務。它就像一座工廠，時刻在執行。 假定工廠的電力有限，一次只能供給一個車間使用。也就是說，一個車間開工的時候，其他車間都必須停工。背後的含義就是，單個CPU一次只能執行一個任務。 程序就好比工廠的車間，它代表CPU所能處理的單個任務。任一時刻，CPU總是執行一個程序

多執行緒與多程序及Python實現【Python實現多程序】

上一篇部落格介紹了多執行緒與多程序的理論部分，這篇部落格將參考部落格以及各種教程完成Python多程序實現部分。 multiprocessing模組 Process 類 multiprocessing.Process(group=None, target=N

python多程序與多執行緒！

有關程序、執行緒、多程序、多執行緒 執行緒與程序 概念 執行緒：是程式執行流的最小單元，是系統獨立排程和分配CPU（獨立執行）的基本單位。 程序：是資源分配的基本單位。一個程序包括多個執行緒。 區別 1.執行緒與資源分配無關，它屬於某一個程序，並與程序內的其他執行緒一起共享程

多執行緒與多程序 非同步IO python

1 效能相關 在編寫爬蟲時，效能的消耗主要在IO請求中，當單程序單執行緒模式下請求URL時必然會引起等待，從而使得請求整體變慢。 1.1 同步執行 import requests def fetch_async(url): response = req