java线程与线程池

一点小情绪

已于 2023-04-18 12:38:48 修改

阅读量102

点赞数 1

文章标签： java jvm 开发语言

于 2023-04-18 12:36:05 首次发布

本文链接：https://blog.csdn.net/qq_45018911/article/details/130218993

版权

java线程与线程池

线程的创建与运行

1、实现Runnable接口

public class ThreadTest implements Runnable{
    @Override
    public void run() {
        System.out.println("创建新线程");
    }

    public static void main(String[] args) {
        ThreadTest threadTest=new ThreadTest();
        Thread thread=new Thread(threadTest);
        thread.start();
    }
}

2、继承Thread类

public class ThreadTest extends  Thread{
    @Override
    public void run() {
        System.out.println("创建新线程");
    }

    public static void main(String[] args) {
        ThreadTest threadTest=new ThreadTest();
        threadTest.start();
    }
}

3、使用FutureTask

public  class CallerTask implements Callable<String> {

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName();
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建FutureTask对象作为任务
        FutureTask<String> futureTask=new FutureTask<>(new CallerTask());
        Thread thread=new Thread(futureTask);
        thread.start();
        //使用get()等待任务结束获取结果
        String result=futureTask.get();
        System.out.println(result);
    }
}

三种方法的区别和联系

前两种方法只能执行任务但是没有返回值，第三种方法可以获取返回值。
Thread类实现了Runnable接口，Thread中run其实是重写了Runnable接口的run()方法，这两种方法本质没有什么区别，如果要实现复杂的线程操作就继承Thread类，如果只是简单的执行一个任务使用Runnable

/*Thread类重写了Runnable接口的run()方法。
 该run()方法首先判断当前是否有Runnable的实现target存在。
 如果存在就执行target.run()
*/
 @Override
    public void run() {
        if (target != null) {
            //这里的target就是构造函数中传递的Runnable
            target.run();
        }
    }

Future: Future 是 Java 中的一个接口，用于表示异步计算的结果。当提交一个 Callable 任务给 ExecutorService 执行时，它会返回一个 Future 对象。通过 Future 对象，你可以查询任务是否已完成，取消任务，或者获取任务执行后的结果。Future 接口的主要方法有 isDone(), cancel(), isCancelled() 和 get()。
FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Future接口和Runnable接口。使用Thread执行callable任务，需要传递Future接口的实现类，用于查看计算的结果，不能像Thread执行Runnable一样直接传递一个target。

线程池中线程的构成

核心线程+非核心线程
核心线程就是线程池中常驻的线程，一般情况下不会将其终止（也可以设置参数空闲一定时间自动关闭），但是使用线程池的意义就在于减少线程创建与销毁的这部分开销，降低资源的消耗。所以这就是线程池中核心线程常驻的原因。
非核心线程是随着线程池中任务数量而动态变化的线程，当核心线程全部使用并且任务队列满了就会动态创建新的线程，可以设置参数空闲一定的时间自动销毁。

线程池工作原理

在这里插入图片描述

当且仅当任务队列已满并且线程池线程数已满才会对任务进行拒绝

java线程池的种类

1.单线程线程池 newSingleThreadExecutor

public static void main(String[] args)  {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        Runnable[] runnables=new Runnable[5];
        for (int i = 0; i < 5; i++) {
            final int k = i;
            runnables[i]=(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getId()+"-" + k);
                    try {
                        Thread.sleep(1000);
                        System.out.println("任务"+k+"休眠了1s");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        for(int i=4;i>=0;i--)
        singleThreadExecutor.execute(runnables[i]);
    }

输出

20-0
任务0休眠了1s
20-1
任务1休眠了1s
20-2
任务2休眠了1s
20-3
任务3休眠了1s
20-4
任务4休眠了1s

线程池中只有一个ID为20的线程，执行任务的顺序就是提交任务的顺序。因此单线程线程池可以保证按照任务的提交顺序进行执行

2.定长线程池 newFixedThreadPool

public static void main(String[] args)  {
        ExecutorService threadExecutor = Executors.newFixedThreadPool(4);
        Runnable[] runnables=new Runnable[5];
        for (int i = 0; i < 5; i++) {
            final int k = i;
            runnables[i]=(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getId()+"-" + k);
                    try {
                        Thread.sleep(1000);
                        System.out.println("任务"+k+"休眠了1s");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        for(int i=4;i>=0;i--){
            threadExecutor.execute(runnables[i]);
        }

    }

输出

21-3
23-1
22-2
20-4
任务3休眠了1s
21-0
任务1休眠了1s
任务2休眠了1s
任务4休眠了1s
任务0休眠了1s

定长线程池核心线程数与最大线程池数相同，程序设置核心线程数为4，提交五个任务，最后一个任务需要在任务队列中等待。

3、可扩容线程池 newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。JVM 自动回收。

 public static void main(String[] args)  {
        ExecutorService threadExecutor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int k = i;
            threadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getId()+"-" + k);
                    try {
                        Thread.sleep(1000);
                        System.out.println("任务"+k+"休眠了1s");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }

    }

输出

21-1
20-0
24-4
23-3
22-2
25-5
26-6
27-7
28-8
29-9
任务4休眠了1s
任务5休眠了1s
任务1休眠了1s
任务0休眠了1s
任务7休眠了1s
任务9休眠了1s
任务6休眠了1s
任务8休眠了1s
任务2休眠了1s
任务3休眠了1s

该线程池线程最大数量为Integer.MAX_VALUE，可以认为是无限大

4、延时、定时启动线程池 newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行，适用于需要多个后台线程执行周期任务的场景。

示例：创建三个任务，一个延时三秒启动，一个每隔三秒周期运行，一个每隔一秒打印当前时间

public static void main(String[] args) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        //设置延时启动
        newScheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延时3秒启动"+Thread.currentThread().getId() );
            }
        }, 3, TimeUnit.SECONDS);
        //每隔三秒运行
        newScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("每隔三秒运行"+Thread.currentThread().getId() );
            }
        }, 3, 3, TimeUnit.SECONDS);
        //每隔一秒打印时间
        newScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            int i = 1;
            @Override
            public void run() {
                System.out.println("当前时间为：" + i++);
            }
        }, 1, 1, TimeUnit.SECONDS);
    }

输出：

当前时间为：1
当前时间为：2
当前时间为：3
每隔三秒运行20
延时3秒启动21
当前时间为：4
当前时间为：5
每隔三秒运行20
当前时间为：6

线程池的状态

关闭线程池可以调用 shutdownNow 和 shutdown 两个方法来实现。

shutdownNow：对正在执行的任务全部发出 interrupt()，停止执行，对还未开始执行的任务全部取消，并且返回还没开始的任务列表。
shutdown：当我们调用shutdown后，线程池将不再接受新的任务，但也不会去强制终止已经提交或者正在执行中的任务。

状态说明

running状态
- 线程池创建后就处于该状态，正常运行的状态。能够向其中添加新任务，对任务进行处理

Shutdown状态
- 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
- 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

Stop状态
- 线程池处于STOP状态，不接收新任务，不处理已提交任务，会中断正在处理的任务。
- 调用线程池shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN) -> STOP。

TIDYING
- 当所有的任务已经停止，线程池会变为TIDYING状态。当线程池处于TIDYING状态时，会执行函数terminated()。
- 当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行任务也为空时，就会由SHUTDOWN -> TIDYING。当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP-> TIDYING。

TERMINATED
- 线程池线程池彻底停止，线程池处于TERMINATED状态，
- 线程池处于TIDYING状态时，执行完terminated()之后，就会TIDYING->TERMINATED
- 当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行任务也为空时，就会由SHUTDOWN -> TIDYING。当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP-> TIDYING。

TERMINATED
- 线程池线程池彻底停止，线程池处于TERMINATED状态，
- 线程池处于TIDYING状态时，执行完terminated()之后，就会TIDYING->TERMINATED

一点小情绪

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java线程与线程池

就是线程池中常驻的线程，一般情况下不会将其终止（也可以设置参数空闲一定时间自动关闭），但是使用线程池的意义就在于减少线程创建与销毁的这部分开销，降低资源的消耗。所以这就是线程池中核心线程常驻的原因。是随着线程池中任务数量而动态变化的线程，当核心线程全部使用并且任务队列满了就会动态创建新的线程，可以设置参数空闲一定的时间自动销毁。创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池中只有一个ID为20的线程，执行任务的顺序就是提交任务的顺序。
复制链接

扫一扫