Os exemplos a seguir discutem principalmente duas questões:
Pergunta 1. O pool de threads é corrigido em tamanho, assumindo que é 5. Então, como o efeito de operação de colocar 10 threads no pool de threads? O status de outros threads?
Pergunta 2. Então, como você remove um encadeamento do pool de threads ou, para ser preciso, para fazer de um thread um fio ocioso?
exemplo:
pacote com.dada.executorService; importar java.util.Concurrent.TimeUnit; classe pública JobThread estende o thread {// Nomeie o thread public JobThread (nome da string, long ThreadId) {super (nome); } @Override public void run () {// Se o thread principal contiver este thread, ele será executado enquanto (mainthread.threadnamemap.containsKey (this.getName ()))) {try {System.out.println ("Nome thread: ---" + this.getName ()); TimeUnit.Seconds.Sleep (4); } catch (Exceção e) {e.printStackTrace (); }} System.out.println ("****************** ENDA ENDERECIMENTO, NOME DO THREADO: ***************" + this.getName ()); }} pacote com.dada.executorService; importar java.util.hashmap; importar java.util.concurrent.executorService; importar java.util.concurrent.executores; importar java.util.Concurrent.TimeUnit; classe pública mainthread {public static final int threadpool_size = 5; // gerar um pool de threads de tamanho fixo Public Static ExecorService Exec = Executores.NewfixedThreadpool (Threadpool_size); // mapa usado para armazenar nomes de threads mapa estático public <string, string> threadnamemap = new hashmap <string, string> (); public static void main (string [] args) {// Insira 10 threads no pool de threads, mas o pool de threads permite apenas um máximo de 5 threads; portanto, os outros 5 threads estão esperando (int i = 0; i <threadpool_size+5; i ++) {string threadName = getThreadName (i); threadnamemap.put (ThreadName, ThreadName); exec.execute (novo JobThread (ThreadName, i)); } System.out.println ("tamanho da tabela de hash:" + threadnamemap.size ()); tente {System.out.println ("O tópico principal dorme por um tempo!"); Timeunit.seconds.sleep (3); } catch (Exceção e) {e.printStackTrace (); System.out.println ("Acorde!"); } // Os seguintes são usados para excluir threads no pool de threads // removethread (0); // removethread (1); // removethread (2); } public static void removethread (int i) {threadnamemap.remove (getThreadName (i)); System.out.println ("Excluir threadThread" + i + ", o tamanho da tabela de hash:" + threadnamap.size ()); } public static string getThreadName (int i) {return "threadName"+i; }} Execute diretamente o resultado do código:
ThreadName: ------ ThreadName0
O tamanho da tabela de hash: 10
Durma por um tempo no tópico principal!
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName4
para concluir:
Encontrado impresso: o nome do thread foi do ThreadName0 para ThreadName4, sem outro nome.
Está provado que 10 threads são colocados no pool de threads, mas o tamanho do pool de threads é de 5 e apenas 5 threads podem ser alocados CPUs. A corrida é a primeira a colocar no pool de threads e os outros threads estão no estado pronto (estado de bloqueio).
Depois de remover os comentários, o código é executado:
ThreadName: ------ ThreadName0
ThreadName: ------ ThreadName2
ThreadName: ------ ThreadName4
O tamanho da tabela de hash: 10
Durma por um tempo no tópico principal!
ThreadName: ------ ThreadName1
ThreadName: ------ ThreadName3
Excluir Thread Thread0, o tamanho da tabela de hash: 9
Excluir thread Thread1, o tamanho da tabela de hash: 8
Exclua Thread Thread2, o tamanho da tabela de hash: 7
**********Indo
**********Indo
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
**********Indo
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
ThreadName: ------ ThreadName5
ThreadName: ------ ThreadName6
ThreadName: ------ ThreadName7
ThreadName: ------ ThreadName4
ThreadName: ------ ThreadName3
para concluir:
A partir dos resultados, podemos ver que, antes de remover o thread, o thread em execução ainda é do Thread0 para Thread4. Após a remoção do thread 0, o novo thread3 do Thread3 começa a ser executado e vai para o ThreadName7 em ordem.
O resumo é o seguinte:
1. O pool de threads é fixo em tamanho, assumindo que é 5. Então, como é o efeito de operação de colocar 10 threads no pool de threads? O status de outros threads?
um. O conceito de pool de threads é que você continua enviando solicitações, mas ele só pode lidar com threads com cotas especificadas, e threads extras esperarão nele.
b. Quando um dos threads concluir o processamento (a execução da empresa é concluída ou o loop while é excitado), o pool de threads retire automaticamente um trabalho da fila de espera e usa um thread inativo para executar o trabalho. Qual pool de threads no pool de threads em execução deve ser baseado na ordem em que é colocado.
2. Então, como remover um fio do pool de threads, ou para ser preciso, para fazer de um thread um fio ocioso?
O pool de threads não pode obter um dos threads e matá -lo, porque o fio principal usando o pool de threads e os threads abertos pelo fio principal estão no mesmo nível, e ninguém tem o direito de dominar a sobrevivência da outra parte. Mas você pode mudar o método e atingir a meta de maneira diplomática.
um. O thread principal mantém uma tabela de hash que pode ser um hashmap. O valor da chave é arbitrário, mas deve ser único e pode indicar exclusivamente um thread.
b. Todos os threads colocados no pool de threads devem gerar um valor de chave e, em seguida, armazená -lo neste hashmap.
c. Para tópicos da classe de loop, como threads de while (verdadeiro). Uma condição precisa ser adicionada para verificar se a chave deste thread existe no hashmap acima. Saia do loop while, se não existir.
d. Embora o encadeamento principal não possa dominar a sobrevivência de outros threads, ele pode colocar ou remover seu próprio hashmap. Nesse ponto, desde que o valor da chave correspondente do encadeamento seja removido do hashmap, o thread sairá automaticamente na próxima vez que ele loop.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.