Saya bermain-main dengan concurrent.futures.
Saat ini panggilan masa depan saya time.sleep(secs).
Tampaknya Future.cancel() hasilnya kurang dari yang saya kira.
Jika masa depan sudah dijalankan, maka time.sleep() tidak dibatalkan olehnya.
Hal yang sama juga terjadi pada parameter batas waktu untuk wait(). Itu tidak membatalkan time.sleep() saya.
Bagaimana cara membatalkan time.sleep() yang dieksekusi secara bersamaan.futures?
Untuk pengujian saya menggunakan ThreadPoolExecutor.
Jika Anda mengirimkan fungsi ke ThreadPoolExecutor, pelaksana akan menjalankan fungsi tersebut di thread dan menyimpan nilai kembaliannya di objek Future. Karena jumlah thread bersamaan terbatas, Anda mempunyai pilihan untuk membatalkan eksekusi tertunda di masa depan, namun setelah kontrol dalam thread pekerja telah diteruskan ke callable, tidak ada cara untuk menghentikan eksekusi.
Pertimbangkan kode ini:
import concurrent.futures as f
import time
T = f.ThreadPoolExecutor(1) # Run at most one function concurrently
def block5():
time.sleep(5)
return 1
q = T.submit(block5)
m = T.submit(block5)
print q.cancel() # Will fail, because q is already running
print m.cancel() # Will work, because q is blocking the only thread, so m is still queued
Secara umum, kapan pun Anda menginginkan sesuatu yang dapat dibatalkan, Anda sendirilah yang bertanggung jawab untuk memastikan hal tersebut.
Namun ada beberapa opsi siap pakai yang tersedia. Misalnya, pertimbangkan untuk menggunakan asyncio, mereka juga memiliki contoh menggunakan sleep. Konsep ini menghindari masalah ini dengan, setiap kali operasi pemblokiran dipanggil, alih-alih mengembalikan kontrol ke loop kontrol yang berjalan dalam konteks terluar, bersama dengan catatan bahwa eksekusi harus dilanjutkan kapan pun hasilnya tersedia - atau, dalam kasus Anda, setelah n detik berlalu.
multiprocessing, interupsi sleep bisa dilakukan, karena tentu saja Anda bisa kill proses lainnya.
- person Phillip; 25.07.2016
kill di concurrent.futures juga. Saya hanya perlu beralih dari ThreadPoolExecutor ke ProcessPoolExecutor. Atau apakah ini salah?
- person guettli; 25.07.2016
_processes tidak didokumentasikan sehingga dapat berubah, dan (b), setelah Anda mendeteksi bahwa masa depan Anda sedang berjalan dan belum selesai, Anda akan berlomba antara masa depan selesai dan Anda menghentikannya -- jika kalah, maka Anda menghentikan tugas lain (yang tidak terkait) dan bukan tugas yang Anda inginkan.
- person Phillip; 25.07.2016
Process secara langsung untuk memasukkan pengamanan Anda sendiri. Kemudian lagi, tentu saja Anda juga dapat membuat subkelas ProcessPoolExecutor dan menambahkan kemampuan penghentian aman.
- person Phillip; 26.07.2016
killproses setiap kali akan berlebihan dan Anda benar-benar harus merancang tugas Anda agar dapat dibatalkan).
- person Phillip; 26.07.2016
asyncio.sleep, bukan time.sleep. time.sleep hanya dapat diinterupsi dengan mengirimkan sinyal ke proses tidur, terlepas dari antarmuka Python. Maksud saya adalah jika Anda ingin tidur dengan cara yang dapat diinterupsi, Anda tidak boleh menggunakan nanosleep(2) sama sekali, melainkan, misalnya, select(2) pada eventfd(2) menggunakan batas waktu. asyncio adalah salah satu kemungkinan pembungkus API ini (dan sejenisnya).
- person Phillip; 01.08.2016
asyncio.sleep memang menjamin bahwa Anda tidur selama jangka waktu tertentu (hingga resolusi loop peristiwa). Saya tidak setuju dengan sifat pertanyaannya. time.sleep digunakan oleh penulis sebagai contoh; yang dia tanyakan adalah bagaimana tugas (yang sedang berjalan) yang hasilnya dirangkum dalam Future dapat dibatalkan.
- person Phillip; 02.08.2016
Saya tidak tahu banyak tentang concurrent.futures, tetapi Anda dapat menggunakan logika ini untuk membagi waktu. Gunakan loop alih-alih sleep.time() atau wait()
for i in range(sec):
sleep(1)
interupsi atau break dapat digunakan untuk keluar dari loop.
Seperti yang tertulis di tautan, Anda dapat gunakan pernyataan with untuk memastikan thread segera dibersihkan, seperti contoh di bawah ini:
import concurrent.futures
import urllib.request
URLS = ['http://www.foxnews.com/',
'http://www.cnn.com/',
'http://europe.wsj.com/',
'http://www.bbc.co.uk/',
'http://some-made-up-domain.com/']
# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
with urllib.request.urlopen(url, timeout=timeout) as conn:
return conn.read()
# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
# Start the load operations and mark each future with its URL
future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
for future in concurrent.futures.as_completed(future_to_url):
url = future_to_url[future]
try:
data = future.result()
except Exception as exc:
print('%r generated an exception: %s' % (url, exc))
else:
print('%r page is %d bytes' % (url, len(data)))
