Para melhorar a estabilidade do desempenho do grande volume de simultaneidade no projeto, os pools de threads são frequentemente usados para executar operações assíncronas com vários threads. Existem dois tipos de threading. Um é implementar a interface executável, que não tem valor de retorno, e o outro é implementar a interface chamada, que possui um valor de retorno.
Quando um dos threads chegou, isso não deve afetar teoricamente os resultados da execução de outros threads, mas os problemas que surgem no projeto indicam que um thread está bloqueado e as interfaces retornadas pelos outros threads estão vazios. Na verdade, é uma pergunta muito simples, mas como a encontrei pela primeira vez, ainda pensei nisso por um tempo. É muito simples, é por causa da linha de bloqueio
O processo não é liberado e, uma vez que a quantidade de simultaneidade é grande, o número de pools de threads estará cheio, para que outros threads estejam em um estado de espera.
Anexada está um código de depuração que eu me escrevi. Quando não consigo pensar em um problema, simulei e talvez o problema seja divulgado.
importar java.util.Concurrent.Callable; importar java.util.concurrent.executionException; importar java.util.concurrent.executorService; importar java.util.concurrent.executores; import java.util.concurrent.future; java.util.Concurrent.TimeOutException; public class FutureTest {public static void main (string [] args) lança interruptedException, executionException, timeoutException {final executores Service Exec = executores.newfixedthreadpool (1); Callable <String> Call = novo Callable <String> () {public String Call () lança interruptedException {// comece a executar o thread de operação consumidor de tempo.sleep (1000 * 2); retornar "1 execução de threads concluída."; }}; Callable <string> Call2 = novo Callable <String> () {public String Call () lança Exceção {// Comece a executar operação de consumo de tempo // Thread.sleep (1000 * 5); retornar "2 execução de threads é concluída."; }}; Callable <string> Call3 = novo Callable <String> () {public String Call () lança Exceção {// Comece a executar operação de consumo de tempo // Thread.sleep (1000 * 5); retornar "3 execução de threads é concluída."; }}; Futuro <string> futuro = Exec.submit (Call); Futuro <string> futuro3 = Exec.submit (Call3); Futuro <string> futuro2 = exec.submit (chamado2); String obj = ""; String obj2 = ""; String obj3 = ""; tente {obj = futuro.get (500, timeUnit.millisEconds); // Defina o tempo limite de processamento de tarefas como} // 1 Segundo Catch (Exceção e) {System.out.println ("Timeout de processamento ...."); E.PrintStackTrace (); } tente {obj3 = futuro3.get (3000, timeUnit.millisEconds); // Defina o tempo limite de processamento de tarefas como} // 1 Segundo Catch (Exceção e) {System.out.println ("Timeout de processamento ......"); E.PrintStackTrace (); } tente {obj2 = futuro2.get (3000, timeUnit.millisEconds);} catch (Exceção e) {System.out.println ("Timeout de processamento ..."); E.PrintStackTrace (); } System.out.println ("3 Tarefa retorna com sucesso:" + obj3); System.out.println ("2 Tarefa retorna com sucesso:" + obj2); System.out.println ("1 tarefa retorna com sucesso:" + obj); exec.shutdown (); }}O exposto acima é a breve discussão das exceções de serviço causadas pelo tempo limite de multi-thread assíncrono em Java. Espero que todos apoiem mais wulin.com ~