python多線程同時執行多個循環

㈠ 什麼是線程（多線程），python多線程的好處

幾乎所有的操作系統都支持同時運行多個任務，一個任務通常就是一個程序，每一個運行中的程序就是一個進程。當一個程序運行時，內部可能包含多個順序執行流，每一個順序執行流就是一個線程。

線程和進程

幾乎所有的操作系統都支持進程的概念，所有運行中的任務通常對應一個進程（Process）。當一個程序進入內存運行時，即變成一個進程。進程是處於運行過程中的程序，並且具有一定的獨立功能。進程是系統進行資源分配和調度的一個獨立單位。

一般而言，進程包含如下三個特徵：

獨立性：進程是系統中獨立存在的實體，它可以擁有自己的獨立的資源，每一個進程都擁有自己的私有的地址空間。在沒有經過進程本身允許的情況下，一個用戶進程不可以直接訪問其他進程的地址空間。

動態性：進程與程序的區別在於，程序只是一個靜態的指令集合，而進程是一個正在系統中活動的指令集合。在進程中加入了時間的概念。進程具有自己的生命周期和各種不同的狀態，在程序中是沒有這些概念的。

並發性：多個進程可以在單個處理器上並發執行，多個進程之間不會互相影響。

並發（Concurrency）和並行（Parallel）是兩個概念，並行指在同一時刻有多條指令在多個處理器上同時執行；並發才旨在同一時刻只能有一條指令執行，但多個進程指令被快速輪換執行，使得在宏觀上具有多個進程同時執行的效果。

大部分操作系統都支持多進程並發執行，現代的操作系統幾乎都支持同時執行多個任務。例如，程序員一邊開著開發工具在寫程序，一邊開著參考手冊備查，同時還使用電腦播放音樂……除此之外，每台電腦運行時還有大量底層的支撐性程序在運行……這些進程看上去像是在同時工作。

但事實的真相是，對於一個 CPU 而言，在某個時間點它只能執行一個程序。也就是說，只能運行一個進程，CPU 不斷地在這些進程之間輪換執行。那麼，為什麼用戶感覺不到任何中斷呢？

這是因為相對人的感覺來說，CPU 的執行速度太快了（如果啟動的程序足夠多，則用戶依然可以感覺到程序的運行速度下降了）。所以，雖然 CPU 在多個進程之間輪換執行，但用戶感覺到好像有多個進程在同時執行。

現代的操作系統都支持多進程的並發執行，但在具體的實現細節上可能因為硬體和操作系統的不同而採用不同的策略。比較常用的策略有：

共用式的多任務操作策略，例如 Windows 3.1 和 Mac OS 9 操作系統採用這種策略；

搶占式的多任務操作策略，其效率更高，目前操作系統大多採用這種策略，例如 Windows NT、Windows 2000 以及 UNIX/Linux 等操作系統。

多線程則擴展了多進程的概念，使得同一個進程可以同時並發處理多個任務。線程（Thread）也被稱作輕量級進程（Lightweight Process），線程是進程的執行單元。就像進程在操作系統中的地位一樣，線程在程序中是獨立的、並發的執行流。

當進程被初始化後，主線程就被創建了。對於絕大多數的應用程序來說，通常僅要求有一個主線程，但也可以在進程內創建多個順序執行流，這些順序執行流就是線程，每一個線程都是獨立的。

線程是進程的組成部分，一個進程可以擁有多個線程，一個線程必須有一個父進程。線程可以擁有自己的堆棧、自己的程序計數器和自己的局部變數，但不擁有系統資源，它與父進程的其他線程共享該進程所擁有的全部資源。因為多個線程共享父進程里的全部資源，因此編程更加方便；但必須更加小心，因為需要確保線程不會妨礙同一進程中的其他線程。

線程可以完成一定的任務，可以與其他線程共享父進程中的共享變數及部分環境，相互之間協同未完成進程所要完成的任務。

線程是獨立運行的，它並不知道進程中是否還有其他線程存在。線程的運行是搶占式的，也就是說，當前運行的線程在任何時候都可能被掛起，以便另外一個線程可以運行。

一個線程可以創建和撤銷另一個線程，同一個進程中的多個線程之間可以並發運行。

從邏輯的角度來看，多線程存在於一個應用程序中，讓一個應用程序可以有多個執行部分同時執行，但操作系統無須將多個線程看作多個獨立的應用，對多線程實現調度和管理，以及資源分配。線程的調度和管理由進程本身負責完成。

簡而言之，一個程序運行後至少有一個進程，在一個進程中可以包含多個線程，但至少要包含一個主線程。

歸納起來可以這樣說，操作系統可以同時執行多個任務，每一個任務就是一個進程，進程可以同時執行多個任務，每一個任務就是一個線程。

多線程的好處

線程在程序中是獨立的、並發的執行流。與分隔的進程相比，進程中線程之間的隔離程度要小，它們共享內存、文件句柄和其他進程應有的狀態

因為線程的劃分尺度小於進程，使得多線程程序的並發性高。進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，從而極大地提高了程序的運行效率。

線程比進程具有更高的性能，這是由於同一個進程中的線程都有共性多個線程共享同一個進程的虛擬空間。線程共享的環境包括進程代碼段、進程的公有數據等，利用這些共享的數據，線程之間很容易實現通信。

操作系統在創建進程時，必須為該進程分配獨立的內存空間，並分配大量的相關資源，但創建線程則簡單得多。因此，使用多線程來實現並發比使用多進程的性能要高得多。

總結起來，使用多線程編程具有如下幾個優點：

進程之間不能共享內存，但線程之間共享內存非常容易。

操作系統在創建進程時，需要為該進程重新分配系統資源，但創建線程的代價則小得多。因此，使用多線程來實現多任務並發執行比使用多進程的效率高。

Python 語言內置了多線程功能支持，而不是單純地作為底層操作系統的調度方式，從而簡化了 Python 的多線程編程。

在實際應用中，多線程是非常有用的。比如一個瀏覽器必須能同時下載多張圖片；一個 Web 伺服器必須能同時響應多個用戶請求；圖形用戶界面（GUI）應用也需要啟動單獨的線程，從主機環境中收集用戶界面事件……總之，多線程在實際編程中的應用是非常廣泛的。

㈡ python怎麼能同時執行代碼（多線程）

多線程不是這個意思。
普通的單線程，比如
代碼塊A
循環代碼塊B
循環代碼塊C
代碼塊D
程序會按順序A，B，C，D這樣執行，而B循環如果沒有結束，C循環不會開始。
如果是多線程，
代碼塊A
新線程：循環代碼塊B
循環代碼塊C
代碼塊D
這樣，B循環新開一個線程運行，原來的線程會繼續運行C，B有沒有結束，不影響C

㈢ python如何同時進行兩個循環

一般的C/C++兩個循環是這樣的：

for(inti=0;i<5;i++)
{
for(intj=0;j<5;j++)
{
printf("%d,%d
",i,j);
}
}

對應的Python是：

foriinrange(5):
forjinrange(5):
printstr(i)+","+str(j)

㈣ 用python ,怎麼實現無限循環(非死循環)

用多線程並行處理while，需要 print x的話，用列隊獲取。

考慮多線程，開一個線程來無限累加。

import threading##多線程
def a:
while True:
print("hello")
def b:
print("xxxx")

threads=[]

擴展資料：

Python 是一門有條理的和強大的面向對象的程序設計語言，類似於Perl, Ruby, Scheme, Java。自從20世紀90年代初Python語言誕生至今，它已被逐漸廣泛應用於系統管理任務的處理和Web編程。Python在設計上堅持了清晰劃一的風格，這使得Python成為一門易讀、易維護，並且被大量用戶所歡迎的、用途廣泛的語言。

㈤ Python多線程的一些問題

python提供了兩個模塊來實現多線程thread 和threading ，thread 有一些缺點，在threading 得到了彌補，為了不浪費你和時間，所以我們直接學習threading 就可以了。
繼續對上面的例子進行改造，引入threadring來同時播放音樂和視頻：
#coding=utf-8import threadingfrom time import ctime,sleepdef music(func): for i in range(2): print "I was listening to %s. %s" %(func,ctime())
sleep(1)def move(func): for i in range(2): print "I was at the %s! %s" %(func,ctime())
sleep(5)

threads = []
t1 = threading.Thread(target=music,args=(u'愛情買賣',))
threads.append(t1)
t2 = threading.Thread(target=move,args=(u'阿凡達',))
threads.append(t2)if __name__ == '__main__': for t in threads:
t.setDaemon(True)
t.start() print "all over %s" %ctime()

import threading
首先導入threading 模塊，這是使用多線程的前提。

threads = []
t1 = threading.Thread(target=music,args=(u'愛情買賣',))
threads.append(t1)
創建了threads數組，創建線程t1,使用threading.Thread()方法，在這個方法中調用music方法target=music，args方法對music進行傳參。 把創建好的線程t1裝到threads數組中。
接著以同樣的方式創建線程t2，並把t2也裝到threads數組。

for t in threads:
t.setDaemon(True)
t.start()
最後通過for循環遍歷數組。（數組被裝載了t1和t2兩個線程）

setDaemon()
setDaemon(True)將線程聲明為守護線程，必須在start() 方法調用之前設置，如果不設置為守護線程程序會被無限掛起。子線程啟動後，父線程也繼續執行下去，當父線程執行完最後一條語句print "all over %s" %ctime()後，沒有等待子線程，直接就退出了，同時子線程也一同結束。

start()
開始線程活動。

運行結果：
>>> ========================= RESTART ================================
>>> I was listening to 愛情買賣. Thu Apr 17 12:51:45 2014 I was at the 阿凡達! Thu Apr 17 12:51:45 2014 all over Thu Apr 17 12:51:45 2014

從執行結果來看，子線程（muisc 、move ）和主線程（print "all over %s" %ctime()）都是同一時間啟動，但由於主線程執行完結束，所以導致子線程也終止。

繼續調整程序：
...if __name__ == '__main__': for t in threads:
t.setDaemon(True)
t.start()

t.join() print "all over %s" %ctime()

我們只對上面的程序加了個join()方法，用於等待線程終止。join（）的作用是，在子線程完成運行之前，這個子線程的父線程將一直被阻塞。
注意: join()方法的位置是在for循環外的，也就是說必須等待for循環里的兩個進程都結束後，才去執行主進程。
運行結果：
>>> ========================= RESTART ================================
>>> I was listening to 愛情買賣. Thu Apr 17 13:04:11 2014 I was at the 阿凡達! Thu Apr 17 13:04:11 2014I was listening to 愛情買賣. Thu Apr 17 13:04:12 2014I was at the 阿凡達! Thu Apr 17 13:04:16 2014all over Thu Apr 17 13:04:21 2014

從執行結果可看到，music 和move 是同時啟動的。
開始時間4分11秒，直到調用主進程為4分22秒，總耗時為10秒。從單線程時減少了2秒，我們可以把music的sleep()的時間調整為4秒。
...def music(func): for i in range(2): print "I was listening to %s. %s" %(func,ctime())
sleep(4)
...

子線程啟動11分27秒，主線程運行11分37秒。
雖然music每首歌曲從1秒延長到了4 ，但通多程線的方式運行腳本，總的時間沒變化。

㈥ 如何多線程（多進程）加速while循環(語言-python)

import numpy as np
import os
import sys
import multiprocessing as mp
import time

def MCS(input_data, med):
#t1 = time.perf_counter()
left = 0
lp = 0

while True:
lp = lp + 1
data_pool = input_data + left
output_data = med * 0.05 * data_pool / (10000 + med)
output_data = np.where(output_data > data_pool, data_pool, output_data)
left = data_pool - output_data
cri = (input_data - output_data) / input_data * 100
#print(lp, data_pool, output_data, cri)
if cri <= 1:
break
t2 = time.perf_counter()
#print(f'Finished in {t2 - t1} seconds')

if __name__ == "__main__":
pool = mp.Pool(processes=5)
tasks = []
for i in np.linspace(0.4, 0.6, num = 10):
tasks.append([100, i])
t1 = time.perf_counter()
pool.starmap(MCS, tasks)
#pool.apply_async(MCS, args=(100, 0.4))
t2 = time.perf_counter()
#pool.join()
#pool.close()
for i in np.linspace(0.4, 0.6, num = 10):
MCS(100, i)
t3 = time.perf_counter()

print(f'Finished in {t2 - t1} seconds')
print(f'Finished in {t3 - t2} seconds')

原因可能是只運行了一個例子，
如圖測試了10個例子，測試結果如下
Finished in 15.062450630997773 seconds
Finished in 73.1936681799998 seconds
並行確實有一定的加速。

㈦ python循環怎麼用多線程去運行

背景：Python腳本：讀取文件中每行，放入列表中；循環讀取列表中的每個元素，並做處理操作。
核心：多線程處理單個for循環函數調用
模塊：threading
第一部分：

：多線程腳本 (該腳本只有兩個線程，t1循環次數<t2)#!/usr/bin/env python#-*- coding: utf8 -*- import sysimport timeimport stringimport threadingimport datetimefileinfo = sys.argv[1] # 讀取文件內容放入列表host_list = []port_list = [] # 定義函數：讀取文件內容放入列表中def CreateList(): f = file(fileinfo,'r') for line in f.readlines(): host_list.append(line.split(' ')[0]) port_list.append(line.split(' ')[1]) return host_list return port_list f.close() # 單線程 循環函數，注釋掉了#def CreateInfo(): # for i in range(0,len(host_list)): # 單線程：直接循環列表# time.sleep(1)# TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')# print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark)# # 定義多線程循環調用函數def MainRange(start,stop): #提供列表index起始位置參數 for i in range(start,stop): time.sleep(1) TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark) # 執行函數，生成列表CreateList()# 列表分割成：兩部分 mid為列表的index中間位置mid = int(len(host_list)/2) # 多線程部分threads = []t1 = threading.Thread(target=MainRange,args=(0,mid))threads.append(t1)t2 = threading.Thread(target=MainRange,args=(mid,len(host_list)))threads.append(t2) for t in threads: t.setDaemon(True) t.start()t.join()print "ok"

以上是腳本內容！！！
----------------------------------------------------------------------
：讀取文件的內容
文件內容：
[root@monitor2 logdb]# cat hostinfo.txt
192.168.10.11 1011
192.168.10.12 1012
192.168.10.13 1013
192.168.10.14 1014
192.168.10.15 1015
192.168.10.16 1016
192.168.10.17 1017
192.168.10.18 1018
192.168.10.19 1019
192.168.10.20 1020
192.168.10.21 1021
192.168.10.22 1022
192.168.10.23 1023
192.168.10.24 1024
192.168.10.25 1025

：輸出結果：
單線程 : 執行腳本：輸出結果：
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.10 and Port is 1010 !!! [2017-01-10 14:25:14]
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:25:15]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:25:16]
.
.
.
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:25:29]

多線程：執行腳本：輸出 結果
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.18 and Port is 1018 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.19 and Port is 1019 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.13 and Port is 1013 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.20 and Port is 1020 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.14 and Port is 1014 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.21 and Port is 1021 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.15 and Port is 1015 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.22 and Port is 1022 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.16 and Port is 1016 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.23 and Port is 1023 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.17 and Port is 1017 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.24 and Port is 1024 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:51:58]

㈧ python 怎麼實現多線程的

線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。

㈨ python 循環中使用多線程

import time
import threading
def p(*listp):
for i in range(0,len(listp)):
print (listp[i])
p1=[]
p2=[]
for i in range(1,100):
if(i%10==1):
p1.append(i)
elif(i%10==2):
p2.append(i)
threads=[]
th1=threading.Thread(target=p,args=(p1))
threads.append(th1)
th2=threading.Thread(target=p,args=(p2))
threads.append(th2)

if __name__=='__main__':
for t in threads:
t.setDaemon(True)
t.start()

㈩ python如何並列運行兩個for循環

咨詢記錄 · 回答於2021-12-22