实现多线程方式你知道几种？

news2024/11/15 11:01:50

实现多线程通常有以下四种方式：

继承 Thread 类。
实现 Runnable 接口。
实现 Callable 接口。
线程池实现多线程。

继承 Thread 类：

public class ThreadDemo extends Thread{

    @Override
    public void run(){
        System.out.println("Thread 类实现多线程,线程名称:"+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadDemo threadDemoOne=new ThreadDemo();
        threadDemoOne.start();
        ThreadDemo threadDemoTwo=new ThreadDemo();
        threadDemoTwo.start();
    }
}

运行结果：

Thread 类实现多线程,线程名称:Thread-1
Thread 类实现多线程,线程名称:Thread-0

继承 Thread 类实现多线程的优缺点：

优点：实现简单，只需要继承 Thread 类，实现 run 方法即可，实际启动线程还是使用 start 方法，start() 方法是一个 native 方法，它将启动一个新线程，并执行 run() 方法。
缺点：我们知道 Java 的单继承的，如果类已经继承了其他的类则不能继承 Thread 类，而且也不能获取线程的返回值。

Thread 类本质上是实现了 Runnable 接口，如下：
在这里插入图片描述

实现 Runnable 接口：

public class RunnableDemo implements Runnable {

    @Override
    public void run() {
        System.out.println("实现 Runnable 接口实现多线程,线程名称:" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        System.out.println("当前线程名称:" + Thread.currentThread().getName());
        Thread thread = new Thread(new RunnableDemo());
        thread.start();
    }

}

执行结果：

当前线程名称:main
实现 Runnable 接口实现多线程,线程名称:Thread-0

实现 Runnable 接口实现多线程的优缺点：

优点：实现简单，实现 Runnable 接口，重写 run 方法即可。
缺点：每次创建一个线程就必须创建一个 Runnable 的实现类，而且也不能获取线程的返回值。

实现 Callable 接口：

public class CallableDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("当前线程的名称是:" + Thread.currentThread().getName());
        return "返回值";
    }

    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new CallableDemo());
        System.out.println("准备开始启动线程，当前线程的名称是:" + Thread.currentThread().getName());
        new Thread(futureTask).start();
        try {
            String str = futureTask.get();
            System.out.println("线程的返回值:" + str);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

执行结果：

准备开始启动线程，当前线程的名称是:main
当前线程的名称是:Thread-0
线程的返回值:返回值

实现 Callable 接口实现多线程的优缺点：

优点：可以获取多线程的返回值，这是前面两种实现多线程的方法做不到的事情。
缺点：每次创建一个线程就必须创建一个 Callable 的实现类。

线程池实现多线程：

public class ExecutorServiceDemo {

    public static void main(String[] args) {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(100);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("executorService-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        for (int a = 0; a < 10; a++) {
            executor.execute(() -> {
                System.out.println("当前线程名称:" + Thread.currentThread().getName());
            });
        }
    }

}

执行结果：

当前线程名称:executorService-2
当前线程名称:executorService-3
当前线程名称:executorService-4
当前线程名称:executorService-4
当前线程名称:executorService-4
当前线程名称:executorService-4
当前线程名称:executorService-4
当前线程名称:executorService-1
当前线程名称:executorService-3
当前线程名称:executorService-2

使用线程池实现多线程的优点：