1. Defina uma classe que herda a classe Thread, substitui o método run na classe, chama o método start do objeto de classe, o método start inicia o thread e chama o método run. A classe Thread é usada para descrever threads; esta classe define uma execução de função, que é usada para armazenar o código a ser executado pelo thread.
2. Defina uma classe para implementar a interface Runnable, substitua os métodos na interface Runnable, crie um objeto thread por meio da classe Thread, passe o objeto de subclasse da interface Runnable como um parâmetro real para o construtor da classe Thread e chame o método start da classe Thread para iniciar o thread. O método run na subclasse da interface Runnable será chamado;
A forma de implementar a interface Runnable evita as limitações causadas pela herança única;
Rosca T;
T.setMaemon(true);//Define o thread como um thread de segundo plano; o thread de segundo plano termina automaticamente quando todos os threads de primeiro plano terminam;
T.notify();//Ativa este tópico;
T.notifyAll();//Ativa todos os threads;
T.interrupt();//interrompe thread;
Thread.sleep(100);//Pausa o thread por 100 milissegundos
sincronizado: por padrão, ele se bloqueia e objetos personalizados também podem ser bloqueados;
Deve haver dois ou mais threads em execução. Vários threads usam o mesmo bloqueio. Deve-se garantir que apenas um thread esteja em execução durante o processo de sincronização;
Determine a sincronização: esclareça quais códigos exigem execução multithread, esclareça os dados compartilhados e esclareça quais instruções no código de execução multithread operam em dados compartilhados;
classe Tickets implementa Runnable
{
tick int privado = 100;
public void run() { // público sincronizado void run()
enquanto (marque > 0) {
sincronizado (isto) {
if (marque > 0) {
tentar {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.toString() + "venda:" + tick--);
}
}
}
}
Como acima: ticks são dados compartilhados. Para operar ticks, você precisa operar de forma sincronizada.
Mecanismo de ativação de espera: Ao operar threads de sincronização, eles devem identificar os bloqueios mantidos pelos threads que operam. Apenas os threads em espera no mesmo bloqueio podem ser despertados por notificação no mesmo bloqueio. ; (isto é: esperar e acordar devem ser o mesmo bloqueio)