Modo Thread-Per-Message (este trabalho é deixado para você)
Quando você está muito ocupado, há um correio no andar de baixo da empresa, então você confia seu colega para ajudá -lo a obter seu correio para que você possa continuar fazendo seu trabalho
No modo Thread-Per-Message, a extremidade delegada da mensagem e a extremidade da execução são encadeamentos diferentes. A extremidade delegada da mensagem informará o encadeamento final da execução, e este trabalho será entregue a você.
Classe anfitriã:
A classe que cria um tópico para solicitações é principalmente abrindo um novo thread, chamando a alça do ajudante e passando o texto a ser impresso.
Public classe Host {Helper final do auxiliar privado = new Helper (); Public void Request (contagem final int, char final C) {System.out.println ("Solicitação inicial"); new Thread () {public void run () {helper.Handle (count, c);}}. Start (); System.out.println ("end");Classe Helper:
Fornece a função de exibição do caractere, o método lentamente simula o tempo de impressão
classe pública Helper {public void Handle (int count, char c) {System.out.println ("Handle Method start"); for (int i = 0; i <count; i ++) {lentamente (); system.out.print (c);} System.out.println ("); System.out.Printlnn ("} system.); {Thread.sleep (100);} catch (interruptedException e) {// TODO Gatch Blocke.printStackTrace ();}}}Classe Principal:
Crie uma instância do host e ligue para o método de solicitação
public static void main (string [] args) {system.out.println ("principal começo"); host host = new host (); host.request (10, 'a'); host.request (20, 'b'); host.request (30, 'c'); system.out.println ("end de ponta");Resultados do teste:
Principal começando
O método de solicitação começou
O final do método de solicitação
O método de solicitação começou
O final do método de solicitação
O método de solicitação começou
O final do método de solicitação
final principal
Inicie o método de manipulação
Inicie o método de manipulação
Inicie o método de manipulação
Bacbacbacbacbacbacbacbacbacba
Método final do manuseio
CBCBCBCBCBCBCBCBCBCBCBCBCBCBCBCBCBCBCB
Método final do manuseio
CCCCCCCCCCCC
Método final do manuseio
A partir dos resultados da operação, podemos ver que o método de solicitação não espera que o método de manipulação seja executado antes da execução, mas chama o método Handle e retorna ao método de solicitação até que a execução termine. Portanto, é equivalente ao método de solicitação, aprovando o trabalho de imprimir um certo número de caracteres a ser executado no método de manipulação, e o método de solicitação pode executar outras instruções no método estúpido sem esperar o método de manipulação ser concluído. Isso também nos diz que, quando algum trabalho consome tempo, novos threads podem ser iniciados nesse modo para executar o processamento. Esse modo pode ser aplicado ao servidor, o que pode reduzir o tempo de resposta do servidor.
Explique o processo e o tópico:
A maior diferença entre threads e processos é se a memória coexiste.
Cada processo tem seu próprio espaço de memória independente. Um processo não pode ler e escrever a memória de outros processos sem autorização. Como o espaço de memória dos processos é independente um do outro, um processo não precisa se preocupar em ser destruído por outros processos.
Os threads podem coexistir. Um thread grava conteúdo na instância e outros threads podem ler o conteúdo da instância. Como vários threads podem acessar a mesma instância, precisamos garantir que ele execute o MUTEX corretamente.
Otimização do design do host:
1. Projete a classe host usando a interface ThreadFactory sob o pacote java.util.concurrent
public class Host {Public void Request (contagem final int, final de char c) {System.out.println ("Método de solicitação inicia"); threadFactory.NewThread (new Runnable () {@OverridePublic void run () {// TODO Auto-Generated MethodElper.Handle (count, c);}; termina ");}}Objeto de instanciação do host correspondente:
Host host = novo host (executores.defaultThreadFactory ());
A vantagem desse design é que o código da instância original criado com o novo depende da classe java.lang.thread e não pode controlar a parte do thread de criação e é menos reutilizável. Se o ThreadFactory for usado para salvar os objetos da classe correspondente e chamar o método Newthread para criar um novo thread, a criação do thread será realizada. Isso não depende mais da classe Thread, mas depende do objeto Threadfactory passado no construtor, que implementa os detalhes do controle da criação de threads.
Redesenhe a classe host usando a interface java.util.concurrent.executor:
A interface Threadfactory anterior oculta os detalhes da criação de threads, mas não oculta as operações de criação de threads. Se a interface do executor for usada, as operações de criação de threads também serão ocultas.
public class Host{private final Helper helper = new Helper();private final Executor executor;public Host(Executor executor){this.executor = executor;}public void request(final int count,final char c){System.out.println("request method has started");executor.execute(new Runnable() {@Overridepublic void run() {// TODO Auto-generated method stubhelper.Handle (contagem, c);}}); System.out.println ("Método de solicitação final");}}Criado usando java.util.concurrent.scheduledExecutorService Class, que pode implementar a operação programada
Public class Host {Helper Final Helper Private Final = new Helper (); Principal Principal Principal ScheduleDexecutorService ScheduleDexecutorService; Public Host (ScheduleDexecutorService ScheduledExecutorService) {this.SCHEDULEDEXECONCOUSVICE = ScheduledExExerService;} Void Public (Final Int Count, ChareDex. Iniciado "); SGONDULEDEXECTORSERVICE.SCHEDULE (new Runnable () {@OverridePublic void run () {// TODO Método Auto-Generado Stubhelper.Handle (contagem, c);}}}, 3l, timeUnit.Seconds); System.out.println (" Solict ");Teste a entrada principal da função:
SGONTULEDEXECONDOVERSERVICE SGONDULEDEXECONDORSERVICE = Executores.NewsCheduledThreadpool (5); host Host = novo host (ScheduleDexecutorService); Try {Host.request (10, 'a'); host.request (20, 'B'); host.request (30, 'C'); Blocke.printStackTrace ();} finalmente {ScheduleDexecutorService.shutdown (); System.out.println ("End Main End");}Resumir
A função do cliente chama o método de solicitação da função do host, e o processamento real da solicitação é entregue ao identificador auxiliar para execução. No entanto, se o cliente chamar o método de manipulação diretamente da solicitação, ele não poderá ser retornado do método de manipulação até que a operação real termine. Isso reduzirá o desempenho da resposta da solicitação. Portanto, a função do host iniciará um novo thread usado para processar a solicitação da função do cliente e permitir que o thread ligue para o identificador, para que o encadeamento que faça a solicitação possa retornar imediatamente do identificador. Este é o modo de rosca por mensagens.