Recentemente, revisei os pontos de conhecimento relevantes do próximo tópico e compartilho com você aqui.
Parceiros que são novos em Java podem ficar confusos sobre threads ou algo assim, e aprender um pouco de cor atordoados.O conhecimento neles sempre parece estonteante, como se eles entendessem, mas não.
Para entender os pontos de conhecimento de threads java, você deve primeiro entender o significado de processos e threads.A seguir está uma descrição resumida de threads e processos.
Um processo é um processo de execução de um programa e é a unidade básica do sistema para executar um programa, portanto, o processo é dinâmico. O sistema que executa um programa é o processo de um processo desde a criação, operação até a morte.
Um thread é semelhante a um processo, mas um thread é uma unidade de execução menor do que um processo. Um processo pode gerar vários threads durante sua execução. Diferente de um processo, vários threads do mesmo tipo compartilham o heap do processo e os recursos da área de método , mas cada thread tem seu próprio contador de programa , pilha de máquina virtual e pilha de método local , de modo que o sistema está gerando um thread ou entre cada thread. Ao alternar entre as tarefas, a carga é muito menor do que a do processo, por isso o thread também é chamado de processo leve.
Para a máquina virtual que foi usada em Java, se você iniciar um método main (), iniciará um processo JVM e esse processo inclui encadeamentos daemon (coleta de lixo) e encadeamentos comuns (tarefas no método principal))
Quando começamos a entrar em contato com threads java, conhecemos duas maneiras comuns de criar threads java, herdando Thread e implementando Runnable. Se você não entende, é só lembrar com antecedência, essa linguagem java é tão estipulada, não tem nada a dizer, e você vai se acostumar depois de muito tempo.
A implementação a seguir escreve dois threads simples:
Herdar Tópico
package com.example.demoproject;
public class ThreadEx extends Thread{
public ThreadEx(String name) {
super(name);
}
/**
* 重写run()方法
*/
@Override
public void run() {
System.out.println("运行方式"+this.getName()+" ThreadEx方法名称："+Thread.currentThread().getName()+" Thread id信息："+Thread.currentThread().getId());
}
}
Implementar o método executável
package com.example.demoproject;
public class ThreadRun implements Runnable {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ThreadRun(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println("ThreadRun方法名称："+Thread.currentThread().getName()+" Thread id信息："+Thread.currentThread().getId());
}
}
Após entrar em contato com a criação de threads, sabemos que existem duas maneiras de iniciar threads: start () e run (). Qual é a diferença entre esses dois métodos? Vamos executar o programa para ver.
package com.example.demoproject;
public class ThreadTest {
public static void main(String[] args) {
ThreadRun runThread = new ThreadRun("runThread");
ThreadEx threadEx1 = new ThreadEx("start");
ThreadEx threadEx2 = new ThreadEx("run");
runThread.run();
threadEx1.start();
threadEx2.run();
}
}
Resultados da execução do programa:
ThreadRun方法名称：main Thread id信息：1
运行方式run ThreadEx方法名称：main Thread id信息：1
运行方式start ThreadEx方法名称：start Thread id信息：11
Process finished with exit code 0
Como você pode ver, há um total de dois threads.Os IDs dos threads são 1 e 11. RunThread implementa o método run (), mas não há método start ().
Podemos ver que o id do thread do método main () é 1, e o id do thread dos dois threads iniciados usando o método run () também é 1. Isso mostra o quê? Usar o método run () não cria um novo encadeamento!
É o encadeamento iniciado pelo método start (). O id do encadeamento é 11, que não é o mesmo encadeamento que main (). Obviamente, um novo encadeamento é iniciado.
Portanto, usar o método run () para executar um thread é equivalente a criar um objeto e, em seguida, chamar um método do objeto. Não há operação de criação de thread. Um novo thread só será criado quando for iniciado com start ().
Obviamente, na codificação real, é raro criar threads sozinho, porque a criação e destruição freqüentes de threads não é uma pequena sobrecarga para os serviços. Geralmente chamamos threads no pool de threads para nos servir.
A propósito, olhe o resultado da operação, você sente algo errado?
Por exemplo, o método start () em meu código é claramente escrito primeiro. Por que o método start () está no final quando ele pode ser executado? Por que não entrar em ordem? Você pode tentar e descobrir que a maioria das situações é consistente com meus resultados de corrida.
Aqui, em primeiro lugar, o método start () reconstruirá um thread. Esta operação, sem dúvida, será demorada, mas isso não afeta a operação do método main (), então quando o novo thread é criado, o main ( O método) foi executado Quando se trata do código a seguir, o método start () aparecerá naturalmente mais lento.