java创建多线程的四种方式

dzWatching

已于 2023-09-22 20:13:26 修改

阅读量1.6k

点赞数 2

文章标签： java jvm 开发语言

于 2022-12-22 23:45:11 首次发布

本文链接：https://blog.csdn.net/qq_47155894/article/details/128401505

版权

JAVA创建多线程的四种方式

继承Thread
实现Runnable接口
实现Callable接口，搭配FutureTask接口
线程池
方式1，2不能拿到返回值，3可以获取返回值
方式1，2，3都不能控制资源
方式4可以控制资源，性能稳定

方式一：继承Thread类

代码：

public class ThreadTest {
    /**
     * 初始化线程的四种方式:
     * 1)继承Thread
     * 2)实现Runnable接口
     * 3)实现Callable接口 + FutureTask (可以拿到返回结果,可以处理异常
     * 4)线程池
     *
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main方法开始了");
//        1)继承Thread
        Thread1 thread1 = new Thread1();
        thread1.start();
        System.out.println("main方法结束了");
    }

    public static class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("当前线程:" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
        }
    }
}

我们在main方法中创建了一个子线程。运行结果如下图所示：
在这里插入图片描述

根据结果可以看到，main方法的主线程和我们创建的子线程并不是同步的。
我们可以通过下图来理解：
在这里插入图片描述

所以四次输出语句依次为上图所示。
main方法主线程和子线程互不影响，主线程结束后并不会导致子线程结束。除非将子线程设置为守护线程。
此外，Thread类也是实现了Runnable接口

方式二：实现Runnable接口

代码：

public class ThreadTest {
    /**
     * 初始化线程的四种方式:
     * 1)继承Thread
     * 2)实现Runnable接口
     * 3)实现Callable接口 + FutureTask (可以拿到返回结果,可以处理异常
     * 4)线程池
     *
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main方法开始了");
//        2)实现Runnable接口
        Thread2 thread2 = new Thread2();
        new Thread(thread2).start();
        System.out.println("main方法结束了");
    }
    
    public static class Thread2 implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程:" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
        }
    }
}

运行结果：
在这里插入图片描述

使用实现Runnable接口的方式创建线程的代码如上所示，与继承Tread类相似。
区别在于启动线程的方式：

        Thread2 thread2 = new Thread2();
        new Thread(thread2).start();

方式三：实现Callable接口，搭配FutureTask接口

public class ThreadTest {
    /**
     * 初始化线程的四种方式:
     * 1)继承Thread
     * 2)实现Runnable接口
     * 3)实现Callable接口 + FutureTask (可以拿到返回结果,可以处理异常
     * 4)线程池
     *
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main方法开始了");

//        3)实现Callable接口 + FutureTask (可以拿到返回结果,可以处理异常
        Thread3 thread3 = new Thread3();
        FutureTask<Integer> futureTask = new FutureTask<>(thread3);
        new Thread(futureTask).start();
        Integer integer = futureTask.get();//futureTask.get()是一个阻塞方法。
        System.out.println("在main主线程中获取thread3线程的结果:"+integer);
        
        System.out.println("main方法结束了");
    }

    public static class Thread3 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程:" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:"+i);
            return i;
        }
    }
}

运行结果：
在这里插入图片描述
Callable和FutureTask搭配，可以获取Callable中计算的结果。同时在主线程中想要获取子线程中的结果，就需要等待子线程执行结束。
流程如图所示：

FutureTask实际上也是实现Runnable接口。
FutureTask的几种构造器：

public FutureTask(Runnable runnable, V result);
public FutureTask(Callable<V> callable);

在实际业务中，以上三种创建线程的方式都不能使用，因为在高并发的情况下会导致资源耗尽

我们将所有的多线程异步任务都交给线程池执行

方式四：线程池

开发中为何使用线程池：

降低资源的消耗
通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
提高响应速度
因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程。
提高线程的可管理性
线程池会根据当前系统的特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

创建线程池的方式

手动创建线程

 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),//LinkedBlockingDeque 默认容量为Integer个
                Executors.defaultThreadFactory(),//默认的线程工厂，也可以自己写
                new ThreadPoolExecutor.AbortPolicy());//拒绝策略 RejectedExecutionHandler中还有其他策略

线程池的七大参数

int corePoolSize
核心线程数,创建后会一直存在，除非设置了允许核心线程库超时（allowCoreThreadTimeOut）；线程池，创建好以后就准备就绪的线程数量，就等待来接收异步任务去执行
可以看作是创建了5个线程，但是未调用start() Thread thread = new Thread();
int maximumPoolSize
最大线程数；控制资源
long keepAliveTime
存活时间，如果当前的线程数量大于core数量，且线程空闲的时间大于指定的时间，就释放空闲的线程（maxmumPoolSize - corePoolSize）
TimeUnit
时间单位
BlockingQueue workQueue
阻塞队列。如果任务有很多，就会将目前多余的任务放在阻塞队列里面
当线程空闲的时候，就会从队列面取出新的任务继续执行
threadFactory
线程的创建工厂
handler
如果阻塞队列满了，按照我们指定的拒绝策略，拒绝执行任务

public static ExecutorService service = Executors.newFixedThreadPool(10);

谈谈线程池的拒绝策略

参考答案
当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就
会采取任务拒绝策略，通常有以下四种策略：

AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
DiscardPolicy：也是丢弃任务，但是不抛出异常。
DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复该过程）。
CallerRunsPolicy：由调用线程处理该任务。

自动创建线程

ExecutorService service = Executors.newCachedThreadPool();
        /**
         * 常见的四种线程池
         * Executors.newCachedThreadPool 带有缓存的，核心是0，所有线程都可回收
         * Executors.newFixedThreadPool 固定线程大小，核心线程数等于最大线程，不可回收
         * Executors.newScheduledThreadPool 做定时任务的线程池
         * Executors.newSingleThreadExecutor 单线程的线程池，后台从队列里面获取任务，依次执行
         */