Artigo Diretório
Prefácio
Por meio deste artigo, primeiro esclareça os cinco estados que existem no encadeamento e, em seguida, use o conhecimento previamente aprendido de classes internas anônimas para implementar o encadeamento e, em seguida, introduza o conceito de conjunto de encadeamentos em multithreading e introduza os três métodos de implementação de conjunto de encadeamentos em combinação com o código. Por fim, entenda o conceito de temporizadores no multithreading e combine duas partes do código para mostrar como usar os temporizadores.
Um, o estado do fio
- Cinco estados
- Novo : o tópico é criado
- Pronto : possui a qualificação de execução da CPU, mas não possui direito de execução da CPU
- Operação : tem a qualificação de execução da CPU e o direito de execução da CPU
- Bloqueio : não possui a qualificação de execução da CPU, nem o direito de execução da CPU
- Morte : não tem a qualificação de execução da CPU, nem o direito de execução da CPU
- Diagrama de estado de execução do thread
Dois, use a classe interna anônima para iniciar o thread
1. Método de implementação 1
- Código básico
new Thread(){
@Override
public void run() {
System.out.println("线程1执行了");
}
}.start();
- Chame a estrutura parametrizada para passar o nome
new Thread("线程2"){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了");
}
}.start();
2. Implementação 2
- Código básico
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程3执行了");
}
}).start();
- Chame a estrutura parametrizada para passar o nome
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了");
}
},"线程4").start();
Três, o conceito e implementação de pool de threads
1. O conceito de pool de threads
- O custo do programa para iniciar um novo thread é relativamente alto, pois ele é projetado para interagir com o sistema operacional. E ao usar o thread pool pode fornecer melhor desempenho, especialmente quando o programa que deseja criar um grande número de threads de curta duração deve considerar o uso de thread pool .
- O pool de threads é na verdade um contêiner que pode nos ajudar a criar um certo número de objetos de thread。
- Depois que o código de cada thread no pool de threads termina, ele não morre, mas retorna ao pool de threads chamado de estado inativo, aguardando o próximo objeto a ser usado .
2. 3 maneiras de implementar pool de threads
- Antes do JDK5, tínhamos que implementar manualmente nosso próprio pool de threads.A partir do JDK5, o Java tem suporte integrado para pools de threads.
- JDK5 adicionou uma nova classe de fábrica de Executores para gerar pool de encadeamentos, existem vários métodos a seguir.
1. Método de implementação de pool de threads um
- public static ExecutorService newCachedThreadPool ()
cria o número de threads correspondentes ao thread de acordo com o número de tarefas(Número de tarefas = número de threads) - Código:
public class 线程池实现方式1 {
public static void main(String[] args) {
//通过工厂类，获取线程池对象
ExecutorService executorService = Executors.newCachedThreadPool();
//给线程池中提交任务（根据任务数量，创建线程个数）
//创建了3个线程完成3个任务
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() +"执行任务1");
}
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName()+"执行任务2");
}
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "执行任务3");
}
}
});
//关闭线程池
executorService.shutdown();
}
}
2. Modo dois de implementação do pool de threads
- public static ExecutorService newFixedThreadPool (int nThreads)
inicializa fixamente o número especificado de threads(O número de threads é especificado arbitrariamente) - Código
public class 线程池的实现方式2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//固定初始化3个线程
ExecutorService executorService = Executors.newFixedThreadPool(3);
//可以传递callable任务,可以获得线程执行完后的结果
Future<Integer> future =executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("线程执行了");
return 100;
}
});
//获取线程执行结果的返回值
Integer integer = future.get();
System.out.println(integer);
}
}
3. Modo de implementação três do pool de threads
- public static ExecutorService newSingleThreadExecutor ()
inicializa um pool de threads(O número de tópicos é 1) - Código:
public class 线程池的实现方式3 {
public static void main(String[] args) {
//初始化一个线程的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行了任务1");
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了任务2");
}
});
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了任务3");
}
});
//注意：该三个任务都是由一个线程完成的
}
}
Quarto, o cronômetro
-
O cronômetro é uma ferramenta de thread amplamente usada que pode ser usada para agendar várias tarefas cronometradas para executar em segundo plano.
-
Em Java, você pode usar Aula de tempo com Classe TimeTask Para cumprir a função de definir o agendamento.
-
Cronômetro:
- temporizador público ()
- public void schedule (tarefa TimerTask, longo atraso):
- agendamento de void público (tarefa TimerTask, atraso longo, período longo);
- public void schedule (tarefa TimerTask, data e hora):
- public void schedule (tarefa TimerTask, Date firstTime, long period):
-
TimerTask: tarefa de cronometragem
- public abstract void run ()
- public boolean cancel ()
Exemplo de código 1:
public class 定时器 {
public static void main(String[] args) {
//timer类，是一种工具，线程用其安排以后在后台线程中执行的任务，可以安排任务执行一次，或者定期重复执行。
Timer t1 = new Timer();
//等待多少毫秒之后，执行定时任务
TimerTask task=new TimerTask() {
@Override
public void run() {
System.out.println("爆炸");
}
};
//任务等待5秒执行，1秒不间断执行一次
t1.schedule(task,1000*5,1000);
//取消定时器
//t1.cancel();
//取消任务
//task.cancel();
}
}
Exemplo de código 2:
public class 定时器2 {
public static void main(String[] args) throws ParseException {
Timer timer = new Timer();
String dateStr="2021-01-23 13:00:00";
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
//使用匿名内部类创建TimeTask
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("从今日起，每日13：00疫情填报");
}
},date,1000*60*60*24);
}
}