jointhreadpython

Ⅰ python join阻塞主線程，多線程還有什麼意義

問題一：
在start前面還是後面append到列表是完全等價的。
因為你的程序(前面省略)，等價於：

# 開啟新線程
thread1.start()
thread2.start()

# 等待所有線程完成
thread1.join()
thread2.join()

print "Exiting Main Thread"

列表不是必須的。
問題二：
使用join是為了阻塞當前線程(即主線程)，直到兩個子線程結束。

Ⅱ python線程 問題請教，怎麼保證子線程執行完畢

首先子線程必須由主線程啟動，所以嚴格意義上的「子線程結束後再執行主線程」是不可能實現，你的意思應該是：主線程創建完子線程後，等待子線程退出，在繼續執行。 你的代碼基本沒有多大問題，只是 Join 方法位置放置不對。 thread1.Start(); // 先啟動所有子線程 thread2.Start(); thread3.Start(); thread4.Start(); thread5.Start(); thread1.Join(); // 然後在等待子線程退出 thread2.Join(); thread3.Join(); thread4.Join(); thread5.Join(); 你先前的代碼： thread1.Start(); // 線程1 啟動 thread1.Join(); // 等待 線程1 退出，線程1 未退出前，後面代碼無法執行 thread2.Start(); // 以下代碼，均同上所述。 thread2.Join(); thread3.Start(); thread3.Join(); thread4.Start(); thread4.Join();

Ⅲ python 多進程和多線程配合

由於python的多線程中存在PIL鎖，因此python的多線程不能利用多核，那麼，由於現在的計算機是多核的，就不能充分利用計算機的多核資源。但是python中的多進程是可以跑在不同的cpu上的。因此，嘗試了多進程+多線程的方式，來做一個任務。比如：從中科大的鏡像源中下載多個rpm包。
#!/usr/bin/pythonimport reimport commandsimport timeimport multiprocessingimport threadingdef download_image(url):
print '*****the %s rpm begin to download *******' % url
commands.getoutput('wget %s' % url)def get_rpm_url_list(url):
commands.getoutput('wget %s' % url)
rpm_info_str = open('index.html').read()

regu_mate = '(?<=<a href=")(.*?)(?=">)'
rpm_list = re.findall(regu_mate, rpm_info_str)

rpm_url_list = [url + rpm_name for rpm_name in rpm_list] print 'the count of rpm list is: ', len(rpm_url_list) return rpm_url_
def multi_thread(rpm_url_list):
threads = [] # url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
# rpm_url_list = get_rpm_url_list(url)
for index in range(len(rpm_url_list)): print 'rpm_url is:', rpm_url_list[index]
one_thread = threading.Thread(target=download_image, args=(rpm_url_list[index],))
threads.append(one_thread)

thread_num = 5 # set threading pool, you have put 4 threads in it
while 1:
count = min(thread_num, len(threads)) print '**********count*********', count ###25,25,...6707%25

res = [] for index in range(count):
x = threads.pop()
res.append(x) for thread_index in res:
thread_index.start() for j in res:
j.join() if not threads:
def multi_process(rpm_url_list):
# process num at the same time is 4
process = []
rpm_url_group_0 = []
rpm_url_group_1 = []
rpm_url_group_2 = []
rpm_url_group_3 = [] for index in range(len(rpm_url_list)): if index % 4 == 0:
rpm_url_group_0.append(rpm_url_list[index]) elif index % 4 == 1:
rpm_url_group_1.append(rpm_url_list[index]) elif index % 4 == 2:
rpm_url_group_2.append(rpm_url_list[index]) elif index % 4 == 3:
rpm_url_group_3.append(rpm_url_list[index])
rpm_url_groups = [rpm_url_group_0, rpm_url_group_1, rpm_url_group_2, rpm_url_group_3] for each_rpm_group in rpm_url_groups:
each_process = multiprocessing.Process(target = multi_thread, args = (each_rpm_group,))
process.append(each_process) for one_process in process:
one_process.start() for one_process in process:
one_process.join()# for each_url in rpm_url_list:# print '*****the %s rpm begin to download *******' %each_url## commands.getoutput('wget %s' %each_url)
def main():
url = 'https://mirrors.ustc.e.cn/centos/7/os/x86_64/Packages/'
url_paas = 'http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/'
url_paas2 ='http://mirrors.ustc.e.cn/fedora/development/26/Server/x86_64/os/Packages/u/'

start_time = time.time()
rpm_list = get_rpm_url_list(url_paas) print multi_process(rpm_list) # print multi_thread(rpm_list)
#print multi_process()
# print multi_thread(rpm_list)
# for index in range(len(rpm_list)):
# print 'rpm_url is:', rpm_list[index]
end_time = time.time() print 'the download time is:', end_time - start_timeprint main()123456789101112131415161718

代碼的功能主要是這樣的：
main（）方法中調用get_rpm_url_list（base_url）方法，獲取要下載的每個rpm包的具體的url地址。其中base_url即中科大基礎的鏡像源的地址，比如：http://mirrors.ustc.e.cn/centos/7.3.1611/paas/x86_64/openshift-origin/，這個地址下有幾十個rpm包，get_rpm_url_list方法將每個rpm包的url地址拼出來並返回。
multi_process（rpm_url_list）啟動多進程方法，在該方法中，會調用多線程方法。該方法啟動4個多進程，將上面方法得到的rpm包的url地址進行分組，分成4組，然後每一個組中的rpm包再最後由不同的線程去執行。從而達到了多進程+多線程的配合使用。
代碼還有需要改進的地方，比如多進程啟動的進程個數和rpm包的url地址分組是硬編碼，這個還需要改進，畢竟，不同的機器，適合同時啟動的進程個數是不同的。

Ⅳ python線程怎麼銷毀

可以新建一個線程作為父線程，然後實際工作是在它的一個子線程裡面做，父線程循環檢測一個變數來決定是否退出。Talk
is
cheap
import
threading
class
TestThread(threading.Thread):
def
__init__(self,
thread_num=0,
timeout=1.0):
super(TestThread,
self).__init__()
self.thread_num
=
thread_num
self.stopped
=
False
self.timeout
=
timeout
def
run(self):
def
target_func():
inp
=
raw_input("Thread
%d:
"
%
self.thread_num)
print('Thread
%s
input
%s'
%
(self.thread_num,
inp))
subthread
=
threading.Thread(target=target_func,
args=())
subthread.setDaemon(True)
subthread.start()
while
not
self.stopped:
subthread.join(self.timeout)
print('Thread
stopped')
def
stop(self):
self.stopped
=
True
def
isStopped(self):
return
self.stopped
thread
=
TestThread()
thread.start()
import
time
print('Main
thread
Wainting')
time.sleep(2)
thread.stop()
thread.join()

Ⅳ 怎麼用python 的多線程列印

#encoding=utf-8
importthreading
importtime

threadLock=threading.Lock()
num=0
classtimer(threading.Thread):
def__init__(self,count,interval):
threading.Thread.__init__(self)
self.interval=interval
self.count=count
defrun(self):
globalnum
whileTrue:
#獲得鎖
threadLock.acquire()
ifnum>=self.count:
#釋放鎖
threadLock.release()
break
num+=1
print'Threadname:%s,%d'%(self.getName(),num)
#釋放鎖
threadLock.release()

time.sleep(self.interval)

if__name__=='__main__':
thread1=timer(1000,1)
thread2=timer(1000,1)
thread1.start()
thread2.start()
thread2.join()
thread2.join()

Ⅵ python 怎麼實現多線程的

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

Ⅶ python 多線程

python支持多線程效果還不錯，很多方面都用到了python 多線程的知識，我前段時間用python 多線程寫了個處理生產者和消費者的問題，把代碼貼出來給你看下：
#encoding=utf-8
import threading
import random
import time
from Queue import Queue

class Procer(threading.Thread):

def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue

def run(self):
for i in range(20):
print self.getName(),'adding',i,'to queue'
self.sharedata.put(i)
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'

# Consumer thread

class Consumer(threading.Thread):

def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue

def run(self):

for i in range(20):
print self.getName(),'got a value:',self.sharedata.get()
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'

# Main thread

def main():

queue = Queue()
procer = Procer('Procer', queue)
consumer = Consumer('Consumer', queue)
print 'Starting threads ...'
procer.start()
consumer.start()
procer.join()
consumer.join()
print 'All threads have terminated.'
if __name__ == '__main__':
main()

如果你想要了解更多的python 多線程知識可以點下面的參考資料的地址，希望對有幫助！

Ⅷ python threading 一定要 join 嗎

Join的作用是眾所周知的，阻塞進程直到線程執行完畢。通用的做法是我們啟動一批線程，最後join這些線程結束，例如：

foriinrange(10):
t=ThreadTest(i)
thread_arr.append(t)

foriinrange(10):
thread_arr[i].start()

foriinrange(10):
thread_arr[i].join()

此處join的原理就是依次檢驗線程池中的線程是否結束，沒有結束就阻塞直到線程結束，如果結束則跳轉執行下一個線程的join函數。

而py的join函數還有一個特殊的功能就是可以設置超時，如下：

Thread.join([timeout])

Wait until the thread terminates. This blocks the calling thread until the thread whosejoin()method is called terminates – either normally or through an unhandled exception – or until the optional timeout occurs.

也就是通過傳給join一個參數來設置超時，也就是超過指定時間join就不在阻塞進程。而在實際應用測試的時候發現並不是所有的線程在超時時間內都結束的，而是順序執行檢驗是否在time_out時間內超時，例如，超時時間設置成2s，前面一個線程在沒有完成的情況下，後面線程執行join會從上一個線程結束時間起再設置2s的超時。

Ⅸ Python中threading的join和setDaemon的區別及用法

python中得thread的一些機制和C/C++不同：在C/C++中，主線程結束後，其子線程會默認被主線程kill掉。而在python中，主線程結束後，會默認等待子線程結束後，主線程才退出。
python對於thread的管理中有兩個函數：join和setDaemon
join：如在一個線程B中調用threada.join()，則threada結束後，線程B才會接著threada.join()往後運行。
setDaemon：主線程A啟動了子線程B，調用b.setDaemaon(True)，則主線程結束時，會把子線程B也殺死，與C/C++中得默認效果是一樣的。
#! /usr/bin/env python
import threading
import time
class myThread(threading.Thread):
def __init__(self, threadname):
threading.Thread.__init__(self, name=threadname)
self.st = 2
def run(self):
time.sleep(self.st)
print self.getName()
def setSt(self, t):
self.st = t
def fun1():
t1.start()
print "fun1 done"
def fun2():
t2.start()
print "fun2 done"
t1=myThread("t1")
t2=myThread("t2")
t2.setSt(10);
# t2.setDaemon(True)
fun1()
fun2()
print "now u will see me"