A programação simultânea de Java observa 1 a 3 maneiras de criar threads em detalhes

O endereço da estação original do curso B: estudo abrangente e aprofundado da programação simultânea em java

Existem três maneiras de criar um thread em java

O primeiro

Crie diretamente usando o novo Thread ()

/**
 * 第一种创建线程方法
 * 最基础的创建线程方法
 * */
@Slf4j(topic = "c.Test1")
public class Test1 {
    public static void main(String[] args) {
    //t1是线程的名字
        Thread t = new Thread("t1"){
            @Override
            public void run() {
                log.debug("running");
            }
        };

        t.start();

        log.debug("running");
    }
}

O segundo

Use a interface Runnable para separar e desacoplar o código da tarefa do encadeamento.Recomenda-se

/**
 * 第二种创建线程方法
 * 使用Runnable创建线程，使得线程和任务代码分开，降低耦合
 * 推荐使用
 * 容易与线程池等高级API配合
 * 让任务类脱离Thread继承关系
 * */
@Slf4j(topic = "c.Test2")
public class Test2 {
    public static void main(String[] args) {
        /**
         * 查看源码可以发现，Runnable接口被 @FunctionalInterface 注释修饰
         * 当接口内只有一个抽象方法的时候，可以使用lambda表达式精简代码
         * */

        Runnable r = () ->{
            log.debug("running");
            log.debug("hello world");
        };


//不使用lambda表达式
//        Runnable r = new Runnable() {
//            public void run() {
//                log.debug("running");
//            }
//        };

        Thread t = new Thread(r,"t2");
        t.start();
    }
}

O terceiro

Use FutureTask com thread

Olhando para o código-fonte, podemos ver que a classe FutureTask implementa a interface RunnableFuture e a interface RunnableFuture herda de Runnable e Future.Não só pode ser passada como um parâmetro para o Thread, mas também FutureTask pode aceitar parâmetros do tipo Callable, para que ele possa retornar resultados, para que possa ser visto como Versão atualizada do Runnable.

/**
 * 第三种创建线程的方法
 * FutureTask配合Thread
 * Future能够接受Callable类型的参数，用来处理有返回结果的情况
 *
 * */
@Slf4j(topic = "c.Test3")
public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //任务对象
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running");
                Thread.sleep(1000);
                return 100;
            }
        });

        Thread t = new Thread(task,"t1");
        t.start();
        //等待线程返回结果
        log.debug("{}",task.get());
    }
}