java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@4aa298b7 rejected from java.util.concurrent.ThreadPoolExecutor@7852e922[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
Ai trimis o sarcină (submit / execute) unui ExecutorService care a fost deja oprit cu shutdown(), sau a cărui coadă e plină. Trimite toate sarcinile înainte de shutdown() și oprește executorul doar la final.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Un ExecutorService (pool de fire de execuție) primește sarcini cu submit sau execute. După shutdown() nu mai acceptă sarcini noi: le termină doar pe cele deja primite. Orice submit ulterior este respins, iar politica implicită (AbortPolicy) aruncă RejectedExecutionException. Mesajul real e lung: Task java.util.concurrent.FutureTask@... rejected from java.util.concurrent.ThreadPoolExecutor@...[Terminated, pool size = 0, ...]. Partea din paranteze arată starea: Shutting down sau Terminated înseamnă că pool-ul a fost oprit.
A doua cauză: un pool cu coadă limitată (ArrayBlockingQueue(100)), unde toate firele sunt ocupate și coada e plină; atunci starea apare ca Running, cu queued tasks la maxim.
Apare des când pool-ul e închis într-un use { } sau finally prea devreme, ori într-o componentă care se oprește înaintea celor care încă trimit sarcini.
De ce apare: cauzele frecvente
1submit după shutdown
pool.shutdown()
pool.submit { trimiteEmail() }pool.submit { trimiteEmail() }
pool.shutdown()Sarcinile se trimit cât timp pool-ul e pornit; shutdown vine la final.
2Pool închis prea devreme
fun proceseaza(comenzi: List<Int>) {
val pool = Executors.newFixedThreadPool(4)
pool.shutdown()
comenzi.forEach { c -> pool.execute { println(c) } }
}fun proceseaza(comenzi: List<Int>) {
val pool = Executors.newFixedThreadPool(4)
comenzi.forEach { c -> pool.execute { println(c) } }
pool.shutdown()
pool.awaitTermination(1, TimeUnit.MINUTES)
}Oprești pool-ul după ultima sarcină și aștepți terminarea lor.
3Coadă limitată plină
ThreadPoolExecutor(2, 2, 0, TimeUnit.SECONDS, ArrayBlockingQueue(10))ThreadPoolExecutor(2, 2, 0, TimeUnit.SECONDS, ArrayBlockingQueue(10), ThreadPoolExecutor.CallerRunsPolicy())CallerRunsPolicy rulează sarcina pe firul care o trimite în loc s-o respingă, ceea ce încetinește natural producătorul.
Repară eroarea, direct în pagină
Programul oprește pool-ul de fire cu shutdown() și abia apoi îi trimite sarcina de trimitere a emailului, așa că se oprește cu RejectedExecutionException. Reordonează apelurile ca sarcina să fie acceptată și programul să afișeze Trimit emailul.
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
fun main() {
val pool = Executors.newFixedThreadPool(2)
pool.shutdown()
pool.submit { println("Trimit emailul") }
pool.awaitTermination(1, TimeUnit.SECONDS)
}Trimit emailul
Indiciu
submit trebuie să vină înainte de shutdown().
Reparația
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
fun main() {
val pool = Executors.newFixedThreadPool(2)
pool.submit { println("Trimit emailul") }
pool.shutdown()
pool.awaitTermination(1, TimeUnit.SECONDS)
}De ce merge
După shutdown(), pool-ul nu mai acceptă sarcini noi, iar politica implicită le respinge cu excepție. Trimisă înainte, sarcina intră în pool; shutdown() doar împiedică altele noi și lasă sarcinile primite să se termine. awaitTermination așteaptă finalizarea lor înainte ca programul să se încheie.
Alte forme ale mesajului
java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@1b6d3586 rejected from java.util.concurrent.ThreadPoolExecutor@4554617c[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]java.util.concurrent.RejectedExecutionException: event executor terminated
Cum o eviți pe viitor
Leagă durata de viață a pool-ului de cea a componentei care îl folosește: creează-l la pornire, oprește-l o singură dată la închidere (shutdown() + awaitTermination). Nu crea și opri un pool la fiecare apel. În cod Kotlin nou, corutinele cu un CoroutineScope și Dispatchers.IO sau Default rezolvă aceleași nevoi cu mai puțină gestiune manuală.
Întrebări frecvente
Care e diferența dintre shutdown și shutdownNow?
shutdown() nu mai primește sarcini noi, dar le termină pe cele existente. shutdownNow() încearcă să le întrerupă și pe cele care rulează și întoarce lista celor care nici n-au început.
Cum citesc starea din mesaj?
Running cu coada plină înseamnă suprasolicitare. Shutting down sau Terminated înseamnă că ai trimis sarcina după shutdown().
Erori înrudite
java.lang.InterruptedException: sleep interrupted Un fir de execuție aștepta (Thread.sleep, join, wait, o coadă blocantă) și alt fir l-a întrerupt cu interrupt(). E un semnal de oprire, nu o defecțiune: prinde InterruptedException acolo unde aștepți și oprește-te curat (sau repune semnalul cu Thread.currentThread().interrupt()). kotlinx.coroutines.JobCancellationException: DeferredCoroutine was cancelled Ai așteptat (await, join) rezultatul unei corutine care fusese anulată, de tine sau de părintele ei. O corutină anulată nu mai are rezultat, așa că await aruncă excepția. Verifică isCancelled înainte, nu anula ce urmează să folosești, sau tratează CancellationException explicit. Exception in thread "main" java.util.ConcurrentModificationException Ai modificat o listă sau un map (remove, add) în timp ce îl parcurgeai cu for. Iteratorul observă schimbarea și se oprește. Folosește removeAll { } / removeIf { }, filter { } pentru o listă nouă, sau un iterator explicit cu iterator.remove(). Învață Kotlin de la zero, cu exerciții la fiecare lecție
Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
