2. 程式人生 > >python基礎-執行緒建立、執行緒池、進\執行緒非同步回撥(add_done_callback)、進\執行緒資料共享、ftp執行緒池

python基礎-執行緒建立、執行緒池、進\執行緒非同步回撥(add_done_callback)、進\執行緒資料共享、ftp執行緒池

阿新 • • 發佈：2019-02-07

執行緒建立

程序只是用來把資源集中到一起（程序只是一個資源單位，或者說資源集合），而執行緒才是cpu上的執行單位。
每個程序有一個地址空間，而且預設就有一個控制執行緒
執行緒就是一條流水線工作的過程，一條流水線必須屬於一個車間，一個車間的工作過程是一個程序

多執行緒（即多個控制執行緒）的概念是，在一個程序中存在多個控制執行緒，多個控制執行緒共享該程序的地址空間，相當於一個車間內有多條流水線，都共用一個車間的資源

我們之前瞭解過程序的2種建立方式
下面的程式碼是2種建立執行緒的方式

from threading import Thread
from multiprocessing import
 
 Process
import time,os

def task():
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())

class Mythread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('%s is running' % os.getpid())
        time.sleep(5
 
)
        print('%s is done' % os.getpid())


if __name__ == '__main__':
    t=Thread(target=task)
    # t=Mythread('xxxxx')
    t.start()

    print('主')

輸出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/1 開啟執行緒的兩種方式.py"
10336 is running
主
10336 is done

Process finished with exit code 0

執行緒程序pid

part1:在主程序下開啟多個執行緒,每個執行緒都跟主程序的pid一樣

from threading import Thread
from multiprocessing import Process
import time,os

def task():
    print('partent：%s self：%s' %(os.getppid(),os.getpid()))
    time.sleep(5)

if __name__ == '__main__':
    t=Thread(target=task,)
    # t=Process(target=task,)
    t.start()
    print('主',os.getppid(),os.getpid())

輸出如下：

partent：9052 self：10120
主 9052 10120

開多個程序,每個程序都有不同的pid

from threading import Thread
from multiprocessing import Process
import time,os

def task():
    print('partent：%s self：%s' %(os.getppid(),os.getpid()))
    time.sleep(5)

if __name__ == '__main__':
    t=Process(target=task,)
    t.start()
    print('主',os.getppid(),os.getpid())

輸出如下：

主 9052 2668
partent：2668 self：8744

執行緒程序資料共享

程序之間資料不共享，但是程序之間可以通過ipc進行資料通訊

from threading import Thread
from multiprocessing import Process
import time,os

n=100
def task():
    global n
    n=0

if __name__ == '__main__':
    t=Process(target=task,)
    t.start()
    t.join()

    print('主',n)

輸出如下：

主 100

執行緒之間記憶體空間共享

from threading import Thread
import time,os

n=100
def task():
    global n
    n=0

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    t.join()

    print('主',n)

輸出如下：

主 0

執行緒ftp

服務端：

import multiprocessing
import threading

import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',8081))
s.listen(5)

def action(conn):
    while True:
        data=conn.recv(1024)
        print(data)
        conn.send(data.upper())

if __name__ == '__main__':

    while True:
        conn,addr=s.accept()

        p=threading.Thread(target=action,args=(conn,))
        p.start()

客戶端：

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))

執行緒池

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import current_thread
import time,random
def task(n):
    print('%s is running' %current_thread().getName())
    time.sleep(random.randint(1,3))
    return n**2

if __name__ == '__main__':

    t=ThreadPoolExecutor(3) #預設是cpu的核數*5
    objs=[]
    for i in range(5):
        obj=t.submit(task,i)
        objs.append(obj)

    t.shutdown(wait=True)
    for obj in objs:
        print(obj.result())
    print('主',current_thread().getName())

輸出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/4 執行緒池.py"
ThreadPoolExecutor-0_0 is running
ThreadPoolExecutor-0_1 is running
ThreadPoolExecutor-0_2 is running

ThreadPoolExecutor-0_0 is running

ThreadPoolExecutor-0_1 is running

0
1
4
9
16
主 MainThread

執行緒池ftp

服務端：

from socket import *
from concurrent.futures import ThreadPoolExecutor
import os

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)

def talk(conn,client_addr):
    print('程序pid: %s' %os.getpid())
    while True:
        try:
            msg=conn.recv(1024)
            if not msg:break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == '__main__':
    p=ThreadPoolExecutor(5)
    while True:
        conn,client_addr=server.accept()
        p.submit(talk,conn,client_addr)

客戶端：

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))

執行緒的一些其他方法

from threading import Thread,current_thread,enumerate,active_count
import time,os

def task():
    print('%s is running' %current_thread().getName())
    time.sleep(5)
    print('%s is done' %current_thread().getName())

if __name__ == '__main__':
    t=Thread(target=task,name='xxxx')
    t.start()
    print(t.name)

    #檢視當前活著的執行緒
    print(enumerate()[0].getName())
    print(active_count())
    print('主',current_thread().getName())

print()

輸出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/3 執行緒物件的其他屬性或方法.py"
xxxx is running
xxxx
MainThread
2
主 MainThread

xxxx is done

非同步-回撥函式

ProcessPoolExecutor方式

我們之前總結的非同步返回結果沒有用到呼叫函式，接下來的是利用了回撥函式

#pip install requests
import requests
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread
import time,os
def get(url):
    print('%s GET %s' %(os.getpid(),url))
    response=requests.get(url)
    time.sleep(3)
    if response.status_code == 200:
        return {'url':url,'text':response.text}

def parse(obj):
    res=obj.result()
    print('[%s] <%s> (%s)' % (os.getpid(), res['url'],len(res['text'])))

if __name__ == '__main__':
    urls = [
        'https://www.python.org',
        'https://www.baidu.com',
        'https://www.jd.com',
        'https://www.tmall.com',
    ]
    t=ProcessPoolExecutor(2)
    for url in urls:
        t.submit(get,url).add_done_callback(parse)
    t.shutdown(wait=True)

    print('主',os.getpid())

程式碼思路是：
t=ProcessPoolExecutor(2)開一個程序池，然後去併發下載網路資料，下載完畢後，
在主程序中add_done_callback去解析
這裡由於主程序、子程序不是同一個程序空間，所以在解析資料時候，在主程序
輸出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/5 補充非同步的概念.py"
5628 GET https://www.python.org
4816 GET https://www.baidu.com


4816 GET https://www.jd.com
[3204] <https://www.baidu.com> (2443)

[3204] <https://www.python.org> (48856)
5628 GET https://www.tmall.com


[3204] <https://www.jd.com> (124541)


[3204] <https://www.tmall.com> (212080)
主 3204

Process finished with exit code 0

ThreadPoolExecutor方式

import requests
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread
import time
import os
def get(url):
    print('%s GET %s,%s' %(current_thread().getName(),os.getpid(),url))
    response=requests.get(url)
    time.sleep(3)
    if response.status_code == 200:
        return {'url':url,'text':response.text}

def parse(obj):
    res=obj.result()
    print('[%s] <%s> (%s)' % (current_thread().getName(), res['url'],len(res['text'])))

if __name__ == '__main__':
    urls = [
        'https://www.python.org',
        'https://www.baidu.com',
        'https://www.jd.com',
        'https://www.tmall.com',
    ]
    t=ThreadPoolExecutor(2)
    for url in urls:
        t.submit(get,url).add_done_callback(parse)
    t.shutdown(wait=True)

    print('主',current_thread().getName(),os.getpid())

程式碼思路是：
t=ThreadPoolExecutor(2)開一個執行緒池，然後去併發下載網路資料，下載完畢後，
在主執行緒程中add_done_callback去解析
這裡由於主執行緒、子執行緒是同一個程序空間，所以在解析資料時候，可能主執行緒、子執行緒都會解析
輸出如下：

E:\python\python_sdk\python.exe "E:/python/py_pro/5 補充非同步的概念.py"
ThreadPoolExecutor-0_0 GET 12956,https://www.python.org
ThreadPoolExecutor-0_1 GET 12956,https://www.baidu.com

[ThreadPoolExecutor-0_1] <https://www.baidu.com> (2443)
ThreadPoolExecutor-0_1 GET 12956,https://www.jd.com

[ThreadPoolExecutor-0_0] <https://www.python.org> (48856)
ThreadPoolExecutor-0_0 GET 12956,https://www.tmall.com

[ThreadPoolExecutor-0_1] <https://www.jd.com> (124541)

[ThreadPoolExecutor-0_0] <https://www.tmall.com> (212079)
主 MainThread 12956

Process finished with exit code 0

相關推薦

python基礎-執行緒建立、執行緒池、進\執行緒非同步回撥(add_done_callback)、進\執行緒資料共享、ftp執行緒池

執行緒建立 程序只是用來把資源集中到一起（程序只是一個資源單位，或者說資源集合），而執行緒才是cpu上的執行單位。 每個程序有一個地址空間，而且預設就有一個控制執行緒 執行緒就是一條流水線工作的過程，一條流水線必須屬於一個車間，一個車間的工作過程

前端入門20-JavaScript進階之非同步回撥的執行時機

宣告 本系列文章內容全部梳理自以下幾個來源： 《JavaScript權威指南》 MDN web docs Github:smyhvae/web Github:goddyZhao/Translation/JavaScript 作為一個前端小白，入門跟著這幾個來源學習，感謝作者的分享，

我的Python成長之路--Day39非同步+回撥機制、執行緒佇列、執行緒Event、協程、Gevent等

1、非同步、同步、阻塞、非阻塞 我們在之前已經簡單介紹過了同步非同步還有阻塞和非阻塞,和本小節我們要介紹的同步呼叫和非同步呼叫有很大關係,所以我們在這裡再囉嗦一下: 1、阻塞與非阻塞指的是程式的兩種執行狀態 阻塞：遇到IO就發生阻塞，程式一旦遇到阻塞操作就會停在原地，並且

程序間的資料共享、程序池的回撥函式和執行緒初識、守護執行緒

一、程序的資料共享 程序間資料是獨立的，可以藉助於佇列或管道實現通訊，二者都是基於訊息傳遞的 雖然程序間資料獨立，但可以通過Manager實現資料共享。 把所有實現了資料共享的比較便捷的類都重新又封裝了一遍，並且在原有的multiprocessing基礎上增加了新

20181104_C#執行緒之Thread_ThreadPool_使用Thread實現回到和帶引數的回撥

C#   .net  Framework多執行緒演變路徑: 1.0    1.1 時代使用Thread 2.0    時代使用ThreadPool 3.0    時代使用Task 4

Java執行緒之非同步回撥(Callback)

●介紹      有時候執行一個任務需要很長時間，單執行緒下執行緒會處於阻塞狀態。這個時候我們會考慮一種非阻塞的處理模式。非阻塞任務在任何程式語言裡都必不可少，Java也不例外。多執行緒就是一個很好的解決辦法。     

java 執行緒間資料共享和android 執行緒間資料共享異同

3 import org.apache.http.HttpResponse; 4 import org.apache.http.client.HttpClient; 5 import org.apache.http.client.methods.HttpGet; 6 import org.apac

Python基礎-使用range建立數字列表以及簡單的統計計算和列表解析

1、使用函式 range() 　　numbers = list(range[1,6]) 　　print (numbers) 　　結果： 　　[1，2，3，4，5] 　　使用range函式，還可以指定步長，例如，列印1~10內的偶數： 　　even_numbers = list(range(2,11

python 管道、資料共享、程序池

一、管道（Pipe）(瞭解) (詳情參考:https://www.cnblogs.com/clschao/articles/9629392.html) 　　程序間通訊（IPC）方式二：管道（不推薦使用，瞭解即可），會導致資料不安全的情況出現，後面我們會說到為什麼會帶來資料 不安全的問題。  

python之路-day32-管道、資料共享、程序池

    一、管道（不推薦使用，瞭解即可） 　　程序間通訊（IPC）方式二：管道（不推薦使用，瞭解即可），會導致資料不安全的情況出現，後面還會提到為什麼 會帶來資料不安全的問題。   1 #建立管道的類： 2 Pipe([duplex]):在程

js中的for迴圈與非同步回撥函式執行順序問題

也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！                for(i=localStorage.length-1;i>=0;i--){//從後往前依次取每條localstorage local_key=local

Python的Socket知識8：程序、資料共享、程序池

理解JavaScript 執行機制及非同步回撥（setTimeout/setInterval/Promise）

對於javascript執行機制的理解一直都是混淆不清。在面試或工作的過程中，也經常會遇到程式碼執行順序或函式生命週期載入等類似的問題，這些多多少少都與javascript的執行機制相關。今天發現一篇很好的文章，欣喜之餘，加以轉載，供感興趣的小夥伴學習，感謝作者分享。 不論

USB資料共享、聯機線、聯網線程式設計介面(API)

本頁面的文字允許在知識共享 署名-相同方式共享 3.0協議和GNU自由文件許可證下修改和再使用。 一、概述 　　當前計算機的USB口已很普遍，USB2.0理論傳輸速率最高為480Mbps，即60MB/s，USB3.0理論傳輸速率最高為5Gbps，即625MB/S。目前USB口主要用於U盤、U

JS-呼叫棧、事件迴圈、訊息佇列（也叫任務隊和回撥佇列）、作業佇列（微任務佇列）

一：呼叫棧是個什麼鬼東西，它具有棧的屬性--後進先出 先看一段簡單的JS程式碼： const second = function(){ console.log('hello there'); } const first = function() { console.log('hi,first'); secon

js進階四(js回撥、promise、promise巢狀、異常處理、jquery使用promise)

同步讀取 我們來看一個從檔案讀取內容的例子，以下是這個例子的目錄結構 我們看下promiser.js的程式碼如下： const fs = require("fs") const path = require("path") function getFile

併發程式設計(5)-管道、資料共享、程序池

概要:     1.管道:Pipe()  也是IPC通訊的一種,     2.資料共享:Manager()     3.程序池:Pool()   &nb

C# 委託的三種呼叫示例（同步呼叫、非同步呼叫、非同步回撥）

首先，通過程式碼定義一個委託和下面三個示例將要呼叫的方法： 程式碼如下: public delegate int AddHandler(int a,int b); public class 加法類 { public static int A

SpringBoot使用Async註解失效分析、解決（spring非同步回撥）

原創 專注JavaWeb開發 2018-12-24 17:30:33 Spring中@Async 在Java應用中，絕大多數情況下都是通過同步的方式來實現互動處理的；但是在處理與第三方系統互動的時候，容易造成響應遲緩的情況，之前大部分都是使用多執行緒來完成此類任務，其實，

JavaScript踩坑筆記10---同步回撥、非同步回撥

JavaScript踩坑筆記10---同步回撥、非同步回撥 同步回撥： 非同步回撥： 同步回撥： 同步回撥指的是，回撥函式和主函式的執行是同步的，回撥函式在主函式內執行，並且主函式要等回撥函式執行完畢以後，才能執行。 舉例說明。 // 定