JAVA多线程的使用和创建的几种方式

Thrad 创建和使用

创建实体类，继承Thread
实现 run() 方法
调用start()方法

public class ThreadDemo extends Thread{

    Logger logger = LoggerFactory.getLogger(ThreadDemo.class);
    
    private String taskName;

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    public ThreadDemo(String name) {
        this.setTaskName(name);
    }
    
    @Override
    public void run() {
        logger.info("线程-----------{}，执行",taskName);
    }
}

Main方法调用

public class ThreadMainDemo {

    public static void main(String[] args) {
        ThreadDemo thread = new ThreadDemo("线程1");
        thread.start();
    }
}
// 输出
线程-----------线程1，执行

Runnable

创建实体类，实现Runnable接口
重写 run 方法
创建Thrad 类，将实现了Runnable接口的类作为参数传递到Thrad构造函数中
调用Thrad中的 start() 方法

public class RunnableDemo implements Runnable{

    Logger logger = LoggerFactory.getLogger(RunnableDemo.class);

    private String taskName;

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    public RunnableDemo(String name) {
        this.setTaskName(name);
    }

    @Override
    public void run() {
        logger.info("基于runnable实现线程的创建：{}",taskName);
    }
}

public class RunnableMainDemo {

    public static void main(String[] args) {
        RunnableDemo runnable = new RunnableDemo("线程runnable");
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
// 输出
 基于runnable实现线程的创建：线程runnable

Callable

Callable是一个函数式接口，此时就可以用lambda表达式更简洁地使用它。Callable是个泛型接口，只有一个方法call，该方法返回类型就是传递进来的V类型

创建实体类，实现Callable
重写 call() 方法
创建FutureTask类，该类实现了 RunnableFuture 接口，可以用来包装Callable或者Runnbale对象
将实现了 Callable的实体类作为形参传入 FutureTask 中的构造器
创建Thread 类，将FutureTask作为形参传入Thread构造器中
调用 Thread类的start()方法
如果要获取call的返回结果，则调用 FutureTask中的 get()方法

// Callable 接受泛型参数，当执行该线程时会返回一个指定的泛型
public class CallableDemo implements Callable<Integer> {

    Logger logger = LoggerFactory.getLogger(CallableDemo.class);

    private String taskName;

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    public CallableDemo(String name) {
        this.setTaskName(name);
    }

    @Override
    public Integer call() throws Exception {
        logger.info("基于callable实现多线程：{}",taskName);
        return 100;
    }
}

public class CallableMainDemo {

    public static void main(String[] args) {
        CallableDemo callable = new CallableDemo("callable");
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 创建 Thread
        Thread thread = new Thread(futureTask);
        thread.start();
        // 获取 callable中的 call方法 结果
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
// 执行结果
基于callable实现多线程：callable
100