python停止thread

① python怎麼讓進程暫停

您的意思是要將進程掛起(Suspend) 而非 阻塞(Block)
如果用sleep() 進程將阻塞
假設進程下有兩個線程 那麼這兩個線程會繼續運行
要使進程掛起 可以考慮使用psutil
import psutil
p = psutil.Process(pid)
p.suspend() #掛起進程
p.resume() #恢復進程

為了證明效果 我寫了一個簡單的進程Process
其下有兩個線程 讀者Reader 和 寫者Writer（簡單的讀者寫者問題）

Process:
import threading

from time import ctime, sleep
import ThreadInReadAndWriteProblem
import multiprocessing
import os

class Process(multiprocessing.Process):

def __init__(self):
multiprocessing.Process.__init__(self) #手動實現父類
pid = os.getpid()

def run(self):
print '當前運行進程PID : %s ' %self.pid #子線程的id與父進程的pid相同 屬於 同一個進程

for i in range(0,5):
r = ThreadInReadAndWriteProblem.Reader()
w = ThreadInReadAndWriteProblem.Writer()
w.start()
r.start()

print '進程阻塞'
sleep(10) #總共運行時間10秒

Reader&Writer
import threading
from time import ctime, sleep
import os

mutex = threading.Lock() #互斥鎖
mutex_readercount = threading.Lock() #計數時的互斥 計算當前正在讀的數目
readerCount = 0 number = 0

#不滿足條件的 進入阻塞狀態

class Reader(threading.Thread): #讀者
def __init__(self):
threading.Thread.__init__(self) #繼承父類構造函數

def run(self):
global mutex
global readerCount
#print '線程PID: %s ' %os.getpid()
while True:
mutex_readercount.acquire()
readerCount +=1
if readerCount == 1:
print '讀者進程等待中，編號%s' %(self.name)
mutex.acquire() == False # 第一個需要申請

mutex_readercount.release()
print '開始讀 , 讀者編號 %s ,現在時間是 %s' %(self.name,ctime())
sleep(2)
print '完成讀 , 讀者編號 %s , 現在時間是 %s' %(self.name,ctime())

mutex_readercount.acquire()
readerCount -= 1
if readerCount == 0: #所有讀者均完成
print '最後一個讀者完成讀 '
mutex.release()
mutex_readercount.release()

class Writer(threading.Thread): #寫者
def __init__(self):
threading.Thread.__init__(self)

def run(self):
global mutex
global writerCount
#print '線程PID： %s' %os.getpid()
while True:
print '寫者進程等待中 編號： %s' %(self.name)
mutex.acquire()
print '開始寫 編號：%s 現在時間是： %s ' %(self.name,ctime())
sleep(5)
print '結束寫 編號: %s 現在時間是 %s' %(self.name,ctime())
mutex.release()

測試程序
import ThreadInReadAndWriteProblem
import
import psutil
import Scheler
from time import ctime, sleep

def main():
p = .Process()
p.start()

sleep(3)

stop(p.pid)
print '進程掛起 %s' %ctime()
sleep(5)

wake(p.pid)
print '喚醒進程 %s' %ctime()

def stop(pid):
print '進程暫停 進程編號 %s ' %(pid)
p = psutil.Process(pid)
p.suspend()

def wake(pid):
print '進程恢復 進程編號 %s ' %(pid)
p = psutil.Process(pid)
p.resume()

if __name__ == '__main__':
main()

結果：
當前運行進程PID : 3096
寫者進程等待中 編號： Thread-2
開始寫 編號：Thread-2 現在時間是： Mon Nov 30 21:12:12 2015
讀者進程等待中，編號Thread-1
寫者進程等待中 編號： Thread-4
進程阻塞
寫者進程等待中 編號： Thread-6
寫者進程等待中 編號： Thread-8
寫者進程等待中 編號： Thread-10
進程暫停 進程編號 3096
進程掛起 Mon Nov 30 21:12:15 2015
進程恢復 進程編號 3096
喚醒進程 Mon Nov 30 21:12:20 2015
結束寫 編號: Thread-2 現在時間是 Mon Nov 30 21:12:20 2015
寫者進程等待中 編號： Thread-2
開始讀 , 讀者編號 Thread-1 ,現在時間是 Mon Nov 30 21:12:20 2015

開始讀 , 讀者編號 Thread-3 ,現在時間是 Mon Nov 30 21:12:20 2015
開始讀 , 讀者編號 Thread-5 ,現在時間是 Mon Nov 30 21:12:20 2015
開始讀 , 讀者編號 Thread-7 ,現在時間是 Mon Nov 30 21:12:20 2015
開始讀 , 讀者編號 Thread-9 ,現在時間是 Mon Nov 30 21:12:20 2015
完成讀 , 讀者編號 Thread-1 , 現在時間是 Mon Nov 30 21:12:22 2015
完成讀 , 讀者編號 Thread-3 , 現在時間是 Mon Nov 30 21:12:22 2015
完成讀 , 讀者編號 Thread-5 , 現在時間是 Mon Nov 30 21:12:22 2015
完成讀 , 讀者編號 Thread-7 , 現在時間是 Mon Nov 30 21:12:22 2015

② 弱問python的問題.怎麼終止一個子線程

等待串口數據導致線程自己sleep而沒有機會執行，主線程的join沒法繼續，方法就是這樣的，換成這個能執行

fromthreadingimport*
importtime

classMyThread(Thread):
defrun(self):
self.ifdo=True;
whileself.ifdo:
print'Iamrunning...'
time.sleep(0.1)

defstop(self):
print'Iwillstopit...'
self.ifdo=False;

tr=MyThread()
tr.setDaemon(True)
tr.start()
time.sleep(1)
tr.stop()
tr.join()

這樣就更直觀了

fromthreadingimport*
importtime

classMyThread(Thread):
defrun(self):
self.ifdo=True;
whileself.ifdo:
print'Iamrunning...'
time.sleep(2)

defstop(self):
print'Iamstoppingit...'
self.ifdo=False;

tr=MyThread()
tr.setDaemon(True)
tr.start()
print'Iwillstopit...'
time.sleep(5)
tr.stop()
tr.join()

③ Python中如何在一段時間後停止程序

用到threading的Timer，也類似單片機那樣子，在中斷程序中再重置定時器，設置中斷，python實例代碼如下：

import threading

import time

def change_user():

print('這是中斷,切換賬號')

t = threading.Timer(3, change_user)

t.start()

#每過3秒切換一次賬號

t = threading.Timer(3, change_user)

t.start()

while True:

print('我在爬數據')

time.sleep(1)

(3)python停止thread擴展閱讀

有時當一個條件成立的情況下，需要終止程序，可以使用sys.exit()退出程序。sys.exit()會引發一個異常：

1、如果這個異常沒有被捕獲，那麼python編譯器將會退出，後面的程序將不會執行。

2、如果這個異常被捕獲(try...except...finally)，捕獲這個異常可以做一些額外的清理工作，後面的程序還會繼續執行。

註：0為正常退出，其他數值（1-127）為不正常，可拋異常事件供捕獲。另一種終止程序的方法os._exit()

一般情況下使用sys.exit()即可，一般在fork出來的子進程中使用os._exit()

採用sys.exit(0)正常終止程序，程序終止後shell運行不受影響。

採用os._exit(0)關閉整個shell，調用sys._exit(0)後整個shell都重啟了（RESTART Shell）。

④ Python中級精華-並發之啟動和停止線程

為了讓代碼能夠並發執行，向創建線程並在核實的時候銷毀它。

由於目的比較單純，只是講解基礎的線程創建方法，所以可以直接使用threading庫中的Thread類來實例化一個線程對象。

例子，用戶輸入兩個數字，並且求其兩個數字的四則運算的結果：

除了以上的一些功能以外，在python線程

中沒有其他的諸如給線程發信號、設置線程調度屬性、執行任何其他高級操作的功能了，如果需要這些功能，就需要手工編寫了。

另外，需要注意的是，由於GIL（全局解釋器鎖）的存在，限制了在python解釋器當中只允許運行一個線程。基於這個原因，不停該使用python線程來處理計算密集型的任務，因為在這種任務重我們希望在多個CPU核心上實現並行處理。Python線程更適合於IO處理以及設計阻塞操作的並發執行任務（即等待IO響應或等待資料庫取出結果等）。

如何判斷線程是否已經啟動？

目的：我們載入了一個線程，但是想要知道這個線程什麼時候才會開始運行？

方法：

線程的核心特徵我認為就是不確定性，因為其什麼時候開始運行，什麼時候被打斷，什麼時候恢復執行，這不是程序員能夠控制的，而是有系統調度

來完成的。如果遇到像某個線程的運行依託於其他某個線程運行到某個狀態時該線程才能開始運行，那麼這就是線程同步

問題，同樣這個問題非常棘手。要解決這類問題我們要藉助threading中的Event對象。

Event其實和條件標記類似，勻速線程

等待某個時間發生。初始狀態時事件被設置成0。如果事件沒有被設置而線程正在等待該事件，那麼線程就會被阻塞，直到事件被設置位置，當有線程設置了這個事件之後，那麼就會喚醒正在等待事件的線程，如果線程等待的事件已經設置了，那麼線程會繼續執行。

一個例子：

如上能夠確定的是，主線程會在線程t運行結束時再運行。

⑤ 求助python多線程，執行到100多個停止了

python 線程 暫停, 恢復, 退出
我們都知道python中可以是threading模塊實現多線程, 但是模塊並沒有提供暫停, 恢復和停止線程的方法, 一旦線程對象調用start方法後, 只能等到對應的方法函數運行完畢. 也就是說一旦start後, 線程就屬於失控狀態. 不過, 我們可以自己實現這些. 一般的方法就是循環地判斷一個標志位, 一旦標志位到達到預定的值, 就退出循環. 這樣就能做到退出線程了. 但暫停和恢復線程就有點難了, 我一直也不清除有什麼好的方法, 直到我看到threading中Event對象的wait方法的描述時.
wait([timeout])
Block until the internal flag is true. If the internal flag is true on entry, return immediately. Otherwise, block until another thread calls set() to set the flag to true, or until the optional timeout occurs.
阻塞, 直到內部的標志位為True時. 如果在內部的標志位在進入時為True時, 立即返回. 否則, 阻塞直到其他線程調用set()方法將標准位設為True, 或者到達了可選的timeout時間.
When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof).
This method returns the internal flag on exit, so it will always return True except if a timeout is given and the operation times out.
當給定了timeout參數且不為None, 它應該是一個浮點數，以秒為單位指定操作的超時（或是分數）。
此方法在退出時返回內部標志，因此除非給定了超時且操作超時，否則它將始終返回True。
Changed in version 2.7: Previously, the method always returned None.
2.7版本以前, 這個方法總會返回None.
<br>
利用wait的阻塞機制, 就能夠實現暫停和恢復了, 再配合循環判斷標識位, 就能實現退出了, 下面是代碼示例:
#!/usr/bin/env python
# coding: utf-8
import threading
import time
class Job(threading.Thread):
def __init__(self, *args, **kwargs):
super(Job, self).__init__(*args, **kwargs)
self.__flag = threading.Event() # 用於暫停線程的標識
self.__flag.set() # 設置為True
self.__running = threading.Event() # 用於停止線程的標識
self.__running.set() # 將running設置為True
def run(self):
while self.__running.isSet():
self.__flag.wait() # 為True時立即返回, 為False時阻塞直到內部的標識位為True後返回
print time.time()
time.sleep(1)
def pause(self):
self.__flag.clear() # 設置為False, 讓線程阻塞
def resume(self):
self.__flag.set() # 設置為True, 讓線程停止阻塞
def stop(self):
self.__flag.set() # 將線程從暫停狀態恢復, 如何已經暫停的話
self.__running.clear() # 設置為False
下面是測試代碼:
a = Job()
a.start()
time.sleep(3)
a.pause()
time.sleep(3)
a.resume()
time.sleep(3)
a.pause()
time.sleep(2)
a.stop()
<br>
測試的結果:
這完成了暫停, 恢復和停止的功能. 但是這里有一個缺點: 無論是暫停還是停止, 都不是瞬時的, 必須等待run函數內部的運行到達標志位判斷時才有效. 也就是說操作會滯後一次.
但是這有時也不一定是壞事. 如果run函數中涉及了文件操作或資料庫操作等, 完整地運行一次後再退出, 反而能夠執行剩餘的資源釋放操作的代碼(例如各種close). 不會出現程序的文件操作符超出上限, 資料庫連接未釋放等尷尬的情況.

⑥ 如何終止Python死循環線程

importtime
importthread

LOCK=True

deftimer(no,interval):
whileLOCK:
print'y'

deftest():
thread.start_new_thread(timer,(1,1))
time.sleep(5)
globalLOCK
LOCK=False
time.sleep(5)

if__name__=='__main__':
test()

可以使用全局變數的，因為線程是共用上下文變數的。

如果解決了您的問題請採納！

如果未解決請繼續追問