三.多线程JUC篇-3.17 ExecutorService API详细讲解

最新推荐文章于 2023-01-29 10:56:08 发布
最新推荐文章于 2023-01-29 10:56:08 发布
阅读量263 收藏
点赞数
分类专栏： # 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42868638/article/details/111861443
版权

1.shutdown

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        isShutDown();
    }

    private static void isShutDown() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(executorService.isShutdown());
        executorService.shutdown();
        System.out.println(executorService.isShutdown());
        executorService.execute(() -> System.out.println("I will be executed after shutDown ???"));
    }
}

//输出：
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.wangwenjun.concurrent.executors.ExecutorServiceExample1$$Lambda$2/558638686@448139f0 rejected from java.util.concurrent.ThreadPoolExecutor@7cca494b[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at java.util.concurrent.Executors$DelegatedExecutorService.execute(Executors.java:668)
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1.isShutDown(ExecutorServiceExample1.java:28)
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1.main(ExecutorServiceExample1.java:9)
false
true

2.terminate

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
       isTerminated();
    }

    private static void isTerminated() {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
        System.out.println(executorService.isShutdown());
        System.out.println(executorService.isTerminated());
        System.out.println(((ThreadPoolExecutor)executorService).isTerminating());
    }
}
//输出：在这里插入代码片 
true
false
true

3.捕获异常

3.1 setUncaughtExceptionHandler

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        executeRunnableError();
    }

    private static void executeRunnableError() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2, new MyThreadFactory());
        IntStream.range(0, 10).boxed().forEach(i -> executorService.execute(() -> System.out.println(1 / 0)));
        executorService.shutdown();
        executorService.awaitTermination(10, TimeUnit.MINUTES);
        System.out.println("=====================================");
    }

    private static class MyThreadFactory implements ThreadFactory {
        private final static AtomicInteger SEQ = new AtomicInteger();

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("My-Thread-" + SEQ.getAndIncrement());
            t.setUncaughtExceptionHandler((i, cause) -> {
                System.out.println("The thread " + i.getName() + " execute failed.");
               // cause.printStackTrace();
                System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
            });
            return t;
        }

    }
}

//输出
=====================================
The thread My-Thread-1 execute failed.
The thread My-Thread-0 execute failed.
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

3.2 线程内部分步骤

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        executeRunnableTask();
    }

    /*
     * <pre>
     *                               |--->操作1
     *                               |--->操作2
     * send request-->store db-->10->|--->操作3-->给出不同的反馈
     *                                  |--->操作4
     *                                  |--->操作5
     * </pre>
     */
    private static void executeRunnableTask() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        IntStream.range(0, 2).boxed().forEach(i -> executorService.execute(
                new MyTask(i) {

                    @Override
                    protected void error(Throwable cause) {
                        System.out.println("The no:" + i + " failed , update status to ERROR.");
                    }

                    @Override
                    protected void done() {
                        System.out.println("The no:" + i + " successfully , update status to DONE.");
                    }

                    @Override
                    protected void doInit() {
                        //do nothing
                    }

                    @Override
                    protected void doExecute() {
                        if(i % 3 == 0) {
                            int tmp = 1 / 0;
                        }
                    }
                }
        ));
        executorService.shutdown();
        executorService.awaitTermination(10, TimeUnit.MINUTES);
        System.out.println("=====================================");
    }

    private static class MyThreadFactory implements ThreadFactory {
        private final static AtomicInteger SEQ = new AtomicInteger();

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("My-Thread-" + SEQ.getAndIncrement());
            t.setUncaughtExceptionHandler((i, cause) -> {
                System.out.println("The thread " + i.getName() + " execute failed.");
                cause.printStackTrace();
                System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
            });
            return t;
        }

    }

    private abstract static class MyTask implements Runnable {
        protected final int no;

        public MyTask(int no) {
            this.no = no;
        }

        @Override
        public void run() {
            try {
                this.doInit();
                this.doExecute();
                this.done();
            } catch (Throwable cause) {
                this.error(cause);
            }
        }

        protected abstract void error(Throwable cause);

        protected abstract void done();

        protected abstract void doExecute();

        protected abstract void doInit();
    }
}

//输出：
The no:1 successfully , update status to DONE.
The no:0 failed , update status to ERROR.
=====================================

4.拒绝策略

4.1 线程池大小足够

public class ExecutorServiceExample1 {
    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3, 10, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(1));
        for (int i = 0; i < 4; i++) {
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" +
                    executor.getQueue().size() + "，已执行完的任务数目：" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}

class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName() + "，正在执行task " + taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task " + taskNum + "执行完毕");

    }
}

//输出：
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程名称：pool-1-thread-1，正在执行task 0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程名称：pool-1-thread-2，正在执行task 1
线程名称：pool-1-thread-3，正在执行task 3
task 0执行完毕
线程名称：pool-1-thread-1，正在执行task 2
task 1执行完毕
task 3执行完毕
task 2执行完毕

Process finished with exit code 0

4.2 AbortPolicy

//将任务数调整为5
//超过的任务（在这里有一个任务）会被拒绝，并抛出任何异常
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程名称：pool-1-thread-1，正在执行task 0
线程名称：pool-1-thread-2，正在执行task 1
线程名称：pool-1-thread-3，正在执行task 3
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.wangwenjun.concurrent.executors.MyTask@135fbaa4 rejected from java.util.concurrent.ThreadPoolExecutor@45ee12a7[Running, pool size = 3, active threads = 3, queued tasks = 1, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1.main(ExecutorServiceExample1.java:14)
task 0执行完毕
线程名称：pool-1-thread-1，正在执行task 2
task 3执行完毕
task 1执行完毕
task 2执行完毕

4.3 DiscardPolicy

//超过的任务（在这里有一个任务）会被拒绝，但不会抛出任何异常
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程名称：pool-1-thread-2，正在执行task 1
线程名称：pool-1-thread-1，正在执行task 0
线程名称：pool-1-thread-3，正在执行task 3
task 1执行完毕
task 0执行完毕
task 3执行完毕
线程名称：pool-1-thread-2，正在执行task 2
task 2执行完毕

4.4 DiscardOldestPolicy

当任务被拒绝添加时，会抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去。

4.4 CallerRunsPolicy

//由调用线程执行，而不是ThreadPoolExecute
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行完的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
线程名称：main，正在执行task 4
线程名称：pool-1-thread-1，正在执行task 0
线程名称：pool-1-thread-2，正在执行task 1
线程名称：pool-1-thread-3，正在执行task 3
task 4执行完毕
task 1执行完毕
task 0执行完毕
线程名称：pool-1-thread-2，正在执行task 2
task 3执行完毕
线程池中线程数目：3，队列中等待执行的任务数目：1，已执行完的任务数目：0
task 2执行完毕

5. ActiveCount

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        test();
    }

    private static void test() throws InterruptedException {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        System.out.println(executorService.getActiveCount());

        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        TimeUnit.MILLISECONDS.sleep(20);
        System.out.println(executorService.getActiveCount());

    }
}

//输出
0
1

5. AllowCoreThreadTimeOut

//如果不设置allowCoreThread，pool会一直存在，因为core threads一直为5
//如果设置了allowCoreThread，等到3秒会，pool会停止
private static void testAllowCoreThreadTimeOut() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.setKeepAliveTime(3, TimeUnit.SECONDS); 
        executorService.allowCoreThreadTimeOut(true); //为true时keepAliveTime的时间必须大于0
        IntStream.range(0, 5).boxed().forEach(i -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
    }

6.remove

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        testRemove();
    }

    private static void testRemove() throws InterruptedException {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(2);
        executorService.setKeepAliveTime(10, TimeUnit.SECONDS);
        //为true时keepAliveTime的时间必须大于1
        executorService.allowCoreThreadTimeOut(true);
        IntStream.range(0, 2).boxed().forEach(i -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println("================ I am finished.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });

        TimeUnit.MILLISECONDS.sleep(20);
        Runnable r = () -> {
            System.out.println("I will never be executed.");
        };
        executorService.execute(r);
        TimeUnit.MILLISECONDS.sleep(20);
        //将queue中的任务删除
        executorService.remove(r);
    }
}

//输出：
================ I am finished.
================ I am finished.

7.beforeExecute和afterExecute

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException {
        testThreadPoolAdvice();
    }



    //beforeExecute和afterExecute类似于切面
    private static void testThreadPoolAdvice() {
        ThreadPoolExecutor executorService = new MyThreadPoolExecutor(1, 2, 30, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1), r -> {
            Thread t = new Thread(r);
            return t;
        }, new ThreadPoolExecutor.AbortPolicy());

        executorService.execute(new MyRunnable(1) {
            @Override
            public void run() {
                System.out.println("=================" + 1/0);
            }
        });
    }

    private abstract static class MyRunnable implements Runnable {
        private final int no;

        public MyRunnable(int no) {
            this.no = no;
        }

        protected int getData() {
            return this.no;
        }
    }

    private static class MyThreadPoolExecutor extends ThreadPoolExecutor {

        public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                    BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        }

        @Override
        protected void beforeExecute(Thread t, Runnable r) {
            System.out.println("init the " + ((MyRunnable)r).getData());
        }

        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            if(null == t) {
                System.out.println("successful " + ((MyRunnable)r).getData());
            } else {
                System.out.println("failed " + t.getMessage());
            }
        }
    }
}

//输出
init the 1
failed / by zero
Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1$1.run(ExecutorServiceExample1.java:27)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:748)

8.invoke和submit

8.1 InvokeAny

//InvokeAny会阻塞主线程，直到某一线程执行完毕
//InvokeAny有一个线程执行完毕，其它线程会取消执行，不在执行
//InvokeAny有一个线程执行完毕，如果其它线程同时执行完毕，就不存在取消一说了
public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        testInvokeAny();
    }



    private static void testInvokeAny() throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(
                i -> (Callable<Integer>) () -> {
                    System.out.println(Thread.currentThread().getName() + " :" + i + " start");
                    TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(20));
                    System.out.println(Thread.currentThread().getName() + " :" + i + " end");
                    return i;
                }
        ).collect(Collectors.toList());
        //这是一个同步方法，执行完成后才会执行后面的任务
        Integer value = executorService.invokeAny(callableList);
        System.out.println("===================finished=====================");
        System.out.println(value);
    }
}

//输出：
pool-1-thread-1 :0 start
pool-1-thread-3 :2 start
pool-1-thread-2 :1 start
pool-1-thread-5 :4 start
pool-1-thread-4 :3 start
pool-1-thread-2 :1 end
===================finished=====================
1

8.2 InvokeAny timeout

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        testInvokeAnyTimeOut();
    }



    private static void testInvokeAnyTimeOut() throws InterruptedException, ExecutionException, TimeoutException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(
                i -> (Callable<Integer>) () -> {
                    System.out.println(Thread.currentThread().getName() + " :" + i + " start");
                    TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(100));
                    System.out.println(Thread.currentThread().getName() + " :" + i + " end");
                    return i;
                }
        ).collect(Collectors.toList());
        //这是一个同步方法，执行完成后才会执行后面的任务
        Integer value = executorService.invokeAny(callableList, 3, TimeUnit.SECONDS);
        System.out.println("===================finished=====================");
        System.out.println(value);
    }
}

//输出
pool-1-thread-1 :0 start
pool-1-thread-4 :3 start
pool-1-thread-3 :2 start
pool-1-thread-2 :1 start
pool-1-thread-5 :4 start
Exception in thread "main" java.util.concurrent.TimeoutException
	at java.util.concurrent.AbstractExecutorService.doInvokeAny(AbstractExecutorService.java:184)
	at java.util.concurrent.AbstractExecutorService.invokeAny(AbstractExecutorService.java:225)
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1.testInvokeAnyTimeOut(ExecutorServiceExample1.java:30)
	at com.wangwenjun.concurrent.executors.ExecutorServiceExample1.main(ExecutorServiceExample1.java:13)

8.3 InvokeAll

//InvokeAll同样是个阻塞方法
//这里发现一个问题，就是callabe执行完后，才进行foreach，这里在jdk1.9已解决或者rxjava框架
public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        testInvokeAll();
    }



    private static void testInvokeAll() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //这是一个同步方法，执行完成后才会执行后面的任务
        executorService.invokeAll(
                IntStream.range(0, 5).boxed().map(
                        i -> (Callable<Integer>) () -> {
                            TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(30));
                            System.out.println(Thread.currentThread().getName() + " :" + i);
                            return i;
                        }
                ).collect(Collectors.toList())
        ).stream().map(future -> {
            try {
                return future.get();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }).forEach(System.out::println);

        System.out.println("===================finished=====================");
    }
}

//输出：
pool-1-thread-1 :0
pool-1-thread-5 :4
pool-1-thread-3 :2
pool-1-thread-4 :3
pool-1-thread-2 :1
0
1
2
3
4
===================finished=====================

8.5 submit

public class ExecutorServiceExample1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        testSubmitRunnable();
        testSubmitRunnableWithResult();
    }



    /**
     * {@link ExecutorService#submit(Runnable)}
     */
    private static void testSubmitRunnable() throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future<?> future = executorService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //get()会产生阻塞，等待前面的任务执行完
        Object NULL = future.get();
        System.out.println("R:" + NULL);
    }

    /**
     * {@link ExecutorService#submit(Runnable, Object)}
     */
    private static void testSubmitRunnableWithResult() throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        String result = "DONE";
        Future<String> future = executorService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, result);
        result = future.get();
        System.out.println("R:" + result);
    }
}

//输出
pool-1-thread-1
R:null

pool-2-thread-1
R:DONE
weixin_42868638
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ScheduledExecutorService API计划任务使用
pys52055的博客
10-05 328
使用callable进行延迟运行 public class MyCallableA implements Callable<String> { @Override public String call() throws Exception { String name = Thread.currentThread().getName(); System.out.println(name+" callA start "+ System.currentTimeMillis());
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
ExecutorService API的使用
pys52055的博客
10-04 160
T invokeAny(Collection<? extends Callable> tasks) throws InterruptedException, ExecutionException; 方法取得第一个完成任务的返回结果，具有线程阻塞特性，当第一个任务完成后会调用interrupt()方法中断其他任务，所有其他任务可以根据 if(Thread.currentThread().isTnterrupt()==true) 来判断任务是否继续执行。 1 无 if(Thread.curren.
七、ExecutorService的API
qq_30118563的博客
11-15 988
七、ExecutorService的API 7.1 API overview 首先来概览一下，这个接口大概有哪些重要API： invokeAny() 与 invokeAll() 具有阻塞特性 invokeAny() 取得第一个完成任务的结果值，当第一个任务执行完成后，调用interrupt() 中断其他任务，所以可以结合if（Thread.intterruptted()）决定任务是否继续运...
ExecutorService的API
Howie_zhw的博客
06-24 729
实现Runnable的线程类不能够获取到线程的执行结果。 java.util.concurrent.ExecutorService的API Future submit(Callable task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。這个可以通过Future.get()获取线程的返回结果。  Future submit(Runnable
java中ExecutorService接口
孤云博客
04-02 2806
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) 一、声明 public interface ExecutorService extends Executor 位于java.util.concurrent包下 所有超级接口：Executor 所有已知...
第7章-JUC多线程v1.1.pdf
02-21
JAVA线程基本学习, JAVA多线程的特性= 线程池: 本质上是一个对象池, 用来管理线程资源. 在任务执行前, 需要从线程池中拿出线程来执行. 在任务执行完成之后, 需要把线程放回线程池. 线程池好处: 降低资源的消耗...
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
最新发布
07-26
在Java多线程并发编程中，ReentrantReadWriteLock（可重入读写锁）是一个重要的同步工具，它属于Java并发包（java.util.concurrent.locks）中的一个类。这个锁提供了比标准的synchronized关键字更细粒度的控制，允许...
实验探究-ExecutorServiceAPI----未完待续！！！！具体细节问题之后补充
一个搬砖工人
11-26 570
**try {}
JUC学习系列二（线程池Executors与ThreadPoolExecutor）
qq_38872310的博客
06-28 519
概念说明 Executor：一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command), ExecutorService：是一个比Executor使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法AbstractExecutorService：ExecutorSer...
JAVA高并发（JUC）之ThreadPool线程池api及工作原理简析
Cocowwy的博客
06-01 1万+
这次讲解的是JUC的线程池，对于ThreadPool，我们可以理解为已经为我们创建了一堆线程，然后再让这些线程去做我们指定的事情。 首先先看看继承图： Executors创建线程的三种方法： ExecutorService threadPool = Executors.newFixedThreadPool(5); //固定容量 ExecutorService threadPool = Executors.newSingleThreadExecutor(); //单例的、单个线程的线程池 Executor
ExecutorService使用
？？？的博客
08-31 414
参考Android API:http://www.android-doc.com/reference/java/util/concurrent/ExecutorService.html eg: ExcecutorService为线程池接口，将线程加进线程池中，execute后不是马上执行，在不久未来异步执行线程。所以会产生并发问题，需要对线程中的共享资源加锁。 import java.uti
（十） ExecutorService
JT的专栏
03-11 334
前言：上一篇FutureTask的执行过程中其实与ExecutorService有关，但是由于对这个知识点不是很熟，所以就略过了，现在专门就这个知识点学习一下。参考博客：Java线程池 ExecutorServicedemo地址：点击打开链接1. ExecutorService的简单使用简单地看了下ExecutorService的API，感觉还是适合一边看源码一边写例子比较靠谱，一上来就写个简单的...
三.多线程JUC篇-3.14 Executor&ExecutorService讲解
中国华的博客
11-16 100
1.概述 在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作 Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runnabl
接口ExecutorService的方法使用
weixin_40472874的博客
08-04 515
1.ExecutorService接口继承于Executor接口（线程池最顶层父类）,抽象类AbstractExecutorService实现了ExecutorService接口，最常用的线程池类ThreadPoolExecutor就是继承于AbstractExecutorService抽象类。 2.接口ExecutorService 中有很多工具方法，ExecutorService接口中的方法有些与 Future 和Callable有关，所以 Future与Callable 的使用是学习 Executor
ExecutorService线程池
qq_27242695的博客
01-29 406
文章目录ExecutorService线程池1 ExecutorService API 介绍1.1 api1.1.1 awaitTermination 方法1.1.2 invokeAll 方法1.1.3 invokeAny方法1.1.4 shutdown 方法1.1.5 shutdownNow方法1.1.6 isShutdown方法1.1.7 submit方法1.1.8 isTerminated方法 ExecutorService线程池 1 ExecutorService API 介绍 1.1 api 1
java并发编程：Executor、Executors、ExecutorService
热门推荐
River的博客
05-30 8万+
Executors    在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好...
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用
12-17
在JUC中，三个核心包分别是： 1. `java.util.concurrent`: 提供了高级并发工具，如ExecutorService、Future、Callable接口以及并发集合等。 2. `java.util.concurrent.atomic`: 包含了原子类，支持在不使用锁的情况...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值