No modelo de desenvolvimento síncrono tradicional, quando chamamos uma função, os dados são passados através dos parâmetros da função, e o resultado final do cálculo é retornado através do valor de retorno da função. No entanto, no modo de desenvolvimento assíncrono multithread, a transmissão e o retorno de dados são muito diferentes do modo de desenvolvimento síncrono. Como a execução e o término dos threads são imprevisíveis, ao transferir e retornar dados, os dados não podem ser retornados por meio de parâmetros de função e instruções de retorno como funções. Este artigo apresenta vários métodos para passar dados para threads pelos motivos acima. No próximo artigo, apresentaremos métodos para retornar dados de threads.
Se você quiser pegar primeiro, você deve dar primeiro. Geralmente, ao usar threads, alguns dados de inicialização são necessários e, em seguida, o thread usa esses dados para processar e retornar os resultados. A primeira coisa a fazer neste processo é passar os dados para o thread.
1. Passe dados por meio de métodos construtores
Ao criar um thread, você deve criar uma instância da classe Thread ou de sua subclasse. Portanto, não é difícil pensar em passar dados para o thread por meio do método construtor da classe thread antes de chamar o método start. E salve os dados recebidos usando variáveis de classe para uso pelo thread (na verdade, usado no método run). O código a seguir demonstra como passar dados pelo construtor:
Copie o código do código da seguinte forma:
pacote mitoread;
classe pública MyThread1 estende Thread
{
nome da string privada;
público MyThread1 (nome da string)
{
este.nome = nome;
}
execução de vazio público ()
{
System.out.println("olá " + nome);
}
público estático void principal(String[] args)
{
Thread thread = new MyThread1("mundo");
thread.start();
}
}
Como esse método transfere dados durante a criação do objeto de thread, os dados já estão no lugar antes da execução do thread, de modo que os dados não serão transmitidos após a execução do thread. Se quiser passar dados mais complexos, você pode usar estruturas de dados como coleções e classes. Embora seja mais seguro usar o método construtor para transferir dados, causará muitos transtornos se houver muitos dados a serem transferidos. Como Java não possui parâmetros padrão, se você quiser obter efeitos semelhantes aos parâmetros padrão, deverá usar sobrecarga. Isso não apenas torna o construtor muito complexo, mas também aumenta muito o número de construtores. Portanto, para evitar esta situação, passe os dados através de métodos de classe ou variáveis de classe.
2. Passe dados por variáveis e métodos
Geralmente há duas oportunidades para passar dados para um objeto. A primeira oportunidade é passar os dados através do método construtor ao criar o objeto. A outra oportunidade é definir uma série de métodos ou variáveis públicas na classe (também chamada de. um campo). Depois de criar o objeto, atribua valores um por um por meio de instâncias do objeto. O código a seguir é uma modificação da classe MyThread1, usando um método setName para definir a variável name:
Copie o código do código da seguinte forma:
pacote mitoread;
classe pública MyThread2 implementa Runnable
{
nome da string privada;
public void setName(Nome da string)
{
este.nome = nome;
}
execução de vazio público ()
{
System.out.println("olá " + nome);
}
público estático void principal(String[] args)
{
MeuThread2 meuThread = new MeuThread2();
myThread.setName("mundo");
Thread thread = new Thread(meuThread);
thread.start();
}
}
3. Passe dados por meio da função de retorno de chamada
Os dois métodos de passagem de dados para threads discutidos acima são os mais comumente usados. Mas ambos os métodos passam dados ativamente para a classe de thread no método principal. Para threads, esses dados são recebidos passivamente. No entanto, em algumas aplicações é necessário obter dados dinamicamente enquanto o thread está em execução. Por exemplo, três números aleatórios são gerados no método run do código a seguir e, em seguida, a soma desses três números aleatórios é calculada através do método de processo. da classe Work e retornar o resultado através do valor da classe Data. Como pode ser visto neste exemplo, três números aleatórios devem ser obtidos antes de retornar o valor. Em outras palavras, esse valor não pode ser passado antecipadamente para a classe de thread.
Copie o código do código da seguinte forma:
pacote mitoread;
dados de classe
{
valor interno público = 0;
}
trabalho de aula
{
processo de void público (dados de dados, números inteiros)
{
para (int n: números)
{
dados.valor += n;
}
}
}
classe pública MyThread3 estende Thread
{
trabalho privado;
público MyThread3 (trabalho de trabalho)
{
este.trabalho = trabalho;
}
execução de vazio público ()
{
java.util.Random aleatório = novo java.util.Random();
Dados dados = novos dados();
int n1 = aleatório.nextInt(1000);
int n2 = random.nextInt(2000);
int n3 = random.nextInt(3000);
work.process(data, n1, n2, n3); // Use a função de retorno de chamada;
System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"
+ String.valorOf(n3) + "=" + dados.valor);
}
público estático void principal(String[] args)
{
Thread thread = new MyThread3(new Work());
thread.start();
}
}
O método de processo no código acima é chamado de função de retorno de chamada. Em essência, as funções de retorno de chamada são funções de evento. Na API do Windows, as funções de retorno de chamada são frequentemente usadas para interagir com os dados entre o programa que chama a API. Portanto, o processo de chamada da função de retorno de chamada é o processo original de acionamento do evento. Neste exemplo, chamar o método process para obter dados equivale a disparar um evento no método run.