实现多线程的几种方式

目录

方式一：实现继承Thread类

方式二：实现Runnable接口

方式三：实现Callable接口

方式四:  用线程池的方式实现多线程 

---

方式一：继承Thread类

public class ThreadDemo extends Thread{
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"多线程开始运行了"+i);
        }
    }

    public static void main(String[] args){
        //线程一
        ThreadDemo threadDemo1 = new ThreadDemo();
        threadDemo1.start();
        //线程二
        new ThreadDemo().start();
    }
}

方式二：实现Runnable接口

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"多线程开始运行了"+i);
        }
    }
    public static void main(String[] args){
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread1 = new Thread(runnableDemo, "线程一");
        //这是设置线程优先级的方法，10优先级最高，1最低
        thread1.setPriority(1);
        thread1.start();
        new Thread(runnableDemo).start();
    }
}

方式三：实现Callable接口

public class CallableDemo implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"多线程开始运行了"+i);
        }
        //返回值
        return 1;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        CallableDemo callableDemo = new CallableDemo();
        FutureTask<Integer> ft1 = new FutureTask<>(callableDemo);
        //创建线程对象
        Thread t1 = new Thread(ft1);
        //开启线程
        t1.start();
        //获取返回值
        Integer a1 = ft1.get();
        System.out.println(a1);

        FutureTask<String> ft2 = new FutureTask<>(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"多线程开始运行了"+i);
            }
            return "这是返回";
        });
        new Thread(ft2).start();
        System.out.println(ft2.get());
    }
}

方式四: 用线程池的方式实现多线程 

注意: 

【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1） FixedThreadPool 和 SingleThreadPool： 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

2） CachedThreadPool： 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM

public class ThreadPoolDemo {

    public static void main(String[] args) {
        //核心线程数
        int corePoolSize = 2;
        //最大线程数
        int maximumPoolSize = 4;
        //超过 corePoolSize 线程数量的线程最大空闲时间
        long keepAliveTime = 2;
        //以秒为时间单位
        TimeUnit unit = TimeUnit.SECONDS;
        //创建工作队列，用于存放提交的等待执行任务
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(2);
        ThreadPoolExecutor threadPoolExecutor = null;
        try {
            //创建线程池
            threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,
                    maximumPoolSize,
                    keepAliveTime,
                    unit,
                    workQueue,
                    new ThreadPoolExecutor.AbortPolicy());

            //循环提交任务
            for (int i = 0; i < 4; i++) {
                final int index = i;
                threadPoolExecutor.submit(() -> {

                    System.out.println(Thread.currentThread().getName()+"多线程开始运行了"+index);
                    
                    try {
                        //模拟线程执行时间，1s
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
                //每个任务提交后休眠100ms再提交下一个任务，用于保证提交顺序
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }

}

注: ThreadPoolExecutor的execute()和submit()方法

基本没有区别，在submit方法中仍然是调用的execute方法进行任务的执行或进入等待队列或拒绝。
submit方法比execute方法多的只是将提交的任务（不管是runnable类型还是callable类型）包装成RunnableFuture然后传递给execute方法执行。
submit方法和execute方法最大的不同点在于submit方法可以获取到任务返回值或任务异常信息，execute方法不能获取任务返回值和异常信息。
RunnableFuture从名字就可以知道，他既是一个Runnable又是一个Future，所以说submit方法提交的任务被包装成RunnableFuture后，后面执行任务的时候运行的就是RunnableFuture.run（）方法，所以最根本的区别在RunnableFuture.run（）方法里。所以这里才是重点关注的地方。