Análise da instância do pool de threads em série Java Concurrency

Prefácio

Nos últimos dois anos de trabalho no Android, através da pesquisa de código-fonte do Android, também terei algum entendimento do processamento concorrente de Java de threading.

Portanto, a questão é: como implementar um pool de threads em série?

Idéias

O que é um pool de threads em série?

Em outras palavras, nossos objetos executáveis ​​devem ter um mecanismo de fila, que entra na cauda da fila em sequência e seleciona executável na cabeça da fila para execução.

Como temos uma ideia, vamos considerar a estrutura de dados necessária?

Como estamos inserindo o objeto executável a partir do final da fila e executando o objeto executável da cabeça da fila, naturalmente precisamos de uma fila. O SDK de Java nos forneceu uma boa estrutura de dados da fila, como fila de ponta dupla: Arraydeque <dunnable>.

• Como envolve a execução de threads, primeiro precisamos ter um pool de threads adequado e usar a classe ThreadPoolExector para construí -lo.
• Como é a execução em série, como podemos manter o mecanismo serial? Através da tentativa e, finalmente, mecanismos, reencapsulamos o objeto executável em um novo objeto executável, executamos o método executável no bloco de tentativa do novo método Runnable Run e chamamos o objeto executável no cabeçalho da fila de execução para fora da fila e colocou o método executado pelo pool do tópico.

Código de amostra

 importar java.util.arraydequ; importar java.util.concurrent.blockQueue; importar java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.threadFactory; import Java.util.Concurrent.TheRead.MoTeRent; importação; java.util.concurrent.atomic.atomicinteger;/*** Criado por Wzy em 16-1-5. */public class Serrielexector {private Runnable mactive; Private ArrayDequ <Runnable> marraydequ = new ArrayDequ <> (); private estático final int cpu_count = RUNTime.GetRuntime (). private estático final int core_pool_size = cpu_count + 1; private estático final int maximum_pool_size = cpu_count * 2 + 1; private estático final int ket_alive = 1; BlockingQueue final estático privado <drunnable> spoolworkQueue = new LinkedBlockingDeque <> (128); Final de estática privada Factory sthreadFactory = new ThreadFactory () {private final AtomicInteger mcount = new AtomicInteger (1); @Override Public Thread Newthread (Runnable r) {return New Thread (R, "serial Thread #" + mcount.getAndIncrement ()); }}; Principal estático privado threadpoolExecutor thread_executor = new threadpoolExecutor (core_pool_size, maximum_pool_size, keep_alive, timeunit.seconds, spoolworkQueue, shreadFactory); public sincronizado void Execute (final Runnable r) {marraydequ.offer (new Runnable () {@Override public void run () {try {r.run ();} finalmente {schedulenext ();}}}); // Quando a primeira vez que você ingressar na fila, o Mactive está vazio, então você precisa chamar o método Schedulenext manualmente se (mactive == null) {schedulenext (); }} private void schedulenext () {if ((mactive = marraydequ.poll ())! = null) {thread_executor.execute (mactive); }} public static void main (string [] args) {seriorlexecutor SerrielexEctor = new SaterrilexEctor (); for (int i = 0; i <10; i ++) {final int j = i; serielelexEctor.execute (new Runnable () {@Override public void run () {System.out.println ("O num é:" + (j + 1); tente {thread.sleep (1000);} catch (interruptException e) {e.printstacktrace ();}}; }}}

Os resultados da execução são os seguintes:

O número é: 1
O número é: 2
O número é: 3
O número é: 4
O número é: 5
O número é: 6
O número é: 7
O número é: 8
O número é: 9
O número é: 10

Resumir

O exposto acima é todo o conteúdo deste artigo sobre a análise de instâncias de pool de tópicos seriais de simultaneidade de Java, e espero que seja útil para todos. Amigos interessados ​​podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!