python多線程for循環

⑴ python多線程中為什麼要用for遍歷所有線程然後依次調用join

join 主要用於進程/線程之間的協同，其功能在於等待目的進程/線程執行完畢。
在此，因為你的線程操作很簡單，功能函數執行完成後線程就結束了。join與否就顯得區別不大。

⑵ 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多線程問題

a、b線程的執行順序是由系統進行調度決定的。這種調度有很強的隨機性。因此a、b線程誰先結束、誰後結束都是未知的。你可以運行以下程序，從而進一步的觀察其中a、b線程的執行情況。

後結束的線程必然是20000。因為最終次數會達到20000。而另一個必然是一個小於等於19999的數。相差次數是系統調度決定，是隨機的。並不存在「循環次數越大，相差就越大」的情況。你可以多試驗幾次試試。

importthreading
TOTAL=0
defmain():
MY_LOCK=threading.Lock()
classCountThread(threading.Thread):
def__init__(self,threadname):
threading.Thread.__init__(self)
self.threadname=threadname


defrun(self):
globalTOTAL
foriinrange(100):
MY_LOCK.acquire()
TOTAL=TOTAL+1
MY_LOCK.release()
print('%s:%s
'%(self.threadname,TOTAL))
a=CountThread("a")
b=CountThread("b")
a.start()
b.start()

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

import threading
def fun1(func):
func.start() #啟動線程2
for i in range(5):
print 'x',i
func.join()
fun2()

def fun2():
for i in range(60):
print 'y',i

tfunc2=threading.Thread(target=fun2)
tfunc1=threading.Thread(target=fun1,args=(tfunc2,))
tfunc1.start() #啟動線程1

⑹ python多線程怎麼用啊，多線程的話是不是能節約時間啊

用pypy執行py腳本比默認的快。Python不支持多cPU，多線程不好用。實在不行多進程吧

⑺ 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 多線程 改變變數需要加鎖么

python的鎖可以獨立提取出來

1
2
3
4
5
6
7
8

mutex = threading.Lock()
#鎖的使用
#創建鎖
mutex = threading.Lock()
#鎖定
mutex.acquire([timeout])
#釋放
mutex.release()

概念
好幾個人問我給資源加鎖是怎麼回事，其實並不是給資源加鎖, 而是用鎖去鎖定資源，你可以定義多個鎖, 像下面的代碼, 當你需要獨占某一資源時，任何一個鎖都可以鎖這個資源
就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import threading
import time

counter = 0
counter_lock = threading.Lock() #只是定義一個鎖,並不是給資源加鎖,你可以定義多個鎖,像下兩行代碼,當你需要佔用這個資源時，任何一個鎖都可以鎖這個資源
counter_lock2 = threading.Lock()
counter_lock3 = threading.Lock()

#可以使用上邊三個鎖的任何一個來鎖定資源

class MyThread(threading.Thread):#使用類定義thread，繼承threading.Thread
def __init__(self,name):
threading.Thread.__init__(self)
self.name = "Thread-" + str(name)
def run(self): #run函數必須實現
global counter,counter_lock #多線程是共享資源的，使用全局變數
time.sleep(1);
if counter_lock.acquire(): #當需要獨佔counter資源時，必須先鎖定，這個鎖可以是任意的一個鎖，可以使用上邊定義的3個鎖中的任意一個
counter += 1
print "I am %s, set counter:%s" % (self.name,counter)
counter_lock.release() #使用完counter資源必須要將這個鎖打開，讓其他線程使用

if __name__ == "__main__":
for i in xrange(1,101):
my_thread = MyThread(i)
my_thread.start()

線程不安全:
最普通的一個多線程小例子。我一筆帶過地講一講，我創建了一個繼承Thread類的子類MyThread，作為我們的線程啟動類。按照規定，重寫Thread的run方法，我們的線程啟動起來後會自動調用該方法。於是我首先創建了10個線程，並將其加入列表中。再使用一個for循環，開啟每個線程。在使用一個for循環，調用join方法等待所有線程結束才退出主線程。
這段代碼看似簡單，但實際上隱藏著一個很大的問題，只是在這里沒有體現出來。你真的以為我創建了10個線程，並按順序調用了這10個線程，每個線程為n增加了1.實際上，有可能是A線程執行了n++，再C線程執行了n++，再B線程執行n++。
這里涉及到一個「鎖」的問題，如果有多個線程同時操作一個對象，如果沒有很好地保護該對象，會造成程序結果的不可預期（比如我們在每個線程的run方法中加入一個time.sleep(1)，並同時輸出線程名稱，則我們會發現，輸出會亂七八糟。因為可能我們的一個print語句只列印出一半的字元，這個線程就被暫停，執行另一個去了，所以我們看到的結果很亂），這種現象叫做「線程不安全」

線程鎖：
於是，Threading模塊為我們提供了一個類，Threading.Lock，鎖。我們創建一個該類對象，在線程函數執行前，「搶占」該鎖，執行完成後，「釋放」該鎖，則我們確保了每次只有一個線程佔有該鎖。這時候對一個公共的對象進行操作，則不會發生線程不安全的現象了。
於是，我們把代碼更改如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# coding : uft-8
__author__ = 'Phtih0n'
import threading, time
class MyThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
global n, lock
time.sleep(1)
if lock.acquire():
print n , self.name
n += 1
lock.release()
if "__main__" == __name__:
n = 1
ThreadList = []
lock = threading.Lock()
for i in range(1, 200):
t = MyThread()
ThreadList.append(t)
for t in ThreadList:
t.start()
for t in ThreadList:
t.join()

1
2
3
4
5
6
7
8
9
10
11

1 Thread-2
2 Thread-3
3 Thread-4
4 Thread-6
5 Thread-7
6 Thread-1
7 Thread-8
8 Thread-9
9 Thread-5

Process finished with exit code 0


我們看到，我們先建立了一個threading.Lock類對象lock,在run方法里，我們使用lock.acquire()獲得了這個鎖。此時，其他的線程就無法再獲得該鎖了，他們就會阻塞在「if lock.acquire()」這里，直到鎖被另一個線程釋放：lock.release()。
所以，if語句中的內容就是一塊完整的代碼，不會再存在執行了一半就暫停去執行別的線程的情況。所以最後結果是整齊的。
就如同在java中，我們使用synchronized關鍵字修飾一個方法，目的一樣，讓某段代碼被一個線程執行時，不會打斷跳到另一個線程中。
這是多線程佔用一個公共對象時候的情況。如果多個線程要調用多個現象，而A線程調用A鎖佔用了A對象，B線程調用了B鎖佔用了B對象,A線程不能調用B對象，B線程不能調用A對象，於是一直等待。這就造成了線程「死鎖」。
Threading模塊中，也有一個類，RLock，稱之為可重入鎖。該鎖對象內部維護著一個Lock和一個counter對象。counter對象記錄了acquire的次數，使得資源可以被多次require。最後，當所有RLock被release後，其他線程才能獲取資源。在同一個線程中，RLock.acquire可以被多次調用，利用該特性，可以解決部分死鎖問題。

⑼ python多線程幾種方法實現

Python進階(二十六)-多線程實現同步的四種方式
臨界資源即那些一次只能被一個線程訪問的資源，典型例子就是列印機，它一次只能被一個程序用來執行列印功能，因為不能多個線程同時操作，而訪問這部分資源的代碼通常稱之為臨界區。
鎖機制
threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行

當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。
信號量
信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):

⑽ python多線程中為什麼要用for遍歷所有線程然後依次調用join

線程之間的輸出，需要在池中中轉，死循環的時間長了，出現滿棧的概率提高，外在表現就是卡一會兒