精华内容
下载资源
问答
  • 2021-02-28 12:19:17

    [java] view plaincopy

    package csdn;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    /**

    * @author nineday

    */

    public class Test {

    public static void main(String args[]) throws InterruptedException {

    ExecutorService exe = Executors.newFixedThreadPool(50);

    for (int i = 1; i <= 5; i++) {

    exe.execute(new SubThread(i));

    }

    exe.shutdown();

    while (true) {

    if (exe.isTerminated()) {

    System.out.println("结束了!");

    break;

    }

    Thread.sleep(200);

    }

    }

    }

    上面是主线程的代码,创建了一个能同时执行2个线程的线程池,并投入5个线程,当5个线程都执行完毕后打印---“结束了!”字符串。

    exe.shutdown();该方法在加入线程队列的线程执行完之前不会执行。

    exe.isTerminated();当shutdown()或者shutdownNow()执行了之后才会执行,并返回true。

    在上面的代码中必须有exe.isTerminated()的判断,否则在投入5个线程到线程池后会直接打印:“结束了”。不能达到我们想要的效果。

    通过while(true)循环判断exe.isTerminated()重生之大文豪的值,为了防止过多的判断浪费资源,可设置线程睡眠Thread.sleep(200);

    正是由于这个睡眠,所以当所有线程池中的线程都执行完后,有可能延迟200ms才执行"结束了"语句。这个参数越小延迟越小,结果越准确。

    下面是子线程,子线程只是简单的将数字i打印出来;

    [java] view plaincopy

    package csdn;

    /**

    * @author nineday

    */

    public class SubThread extends Thread{

    private final int i;

    public SubThread(int i){

    this.i = i;

    }

    @Override

    public void run(){

    System.out.println(i);

    }

    }

    执行结果:

    [plain] view plaincopy

    run:

    3

    1

    4

    5

    2

    结束了!

    成功构建 (总时间: 2 秒)

    子线程执行顺序不能控制,所以输出的结果是乱序的。

    阅读(8790) | 评论(0) | 转发(0) |

    更多相关内容
  • 线程池配置 ... * 执行io操作的线程池 */ @Bean public ThreadPoolExecutor ioPoolExecutor() { AtomicInteger incr = new AtomicInteger(0); ThreadFactory threadFactory = runnable -> {

    线程池配置

    @Configuration
    @Slf4j
    public class BeanConfig {
    
        /**
         * 执行io操作的线程池
         */
        @Bean
        public ThreadPoolExecutor ioPoolExecutor() {
            AtomicInteger incr = new AtomicInteger(0);
            ThreadFactory threadFactory = runnable -> {
                Thread thread = new Thread(runnable);
                int i = incr.incrementAndGet();
                if (i > 1000) {
                    incr.set(0);
                    i = incr.incrementAndGet();
                }
                thread.setName("stardust-backend-" + i);
                return thread;
            };
            return new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() * 2 + 1,
                                          Runtime.getRuntime().availableProcessors() * 2 + 1, 1, TimeUnit.MINUTES,
                                          new ArrayBlockingQueue<>(100), threadFactory,
                                          new ThreadPoolExecutor.CallerRunsPolicy());
        }
    }

    等待线程池

        
        @Autowired
        private ThreadPoolExecutor ioPoolExecutor;
    
        public Boolean submit(int i) throws InterruptedException {
            int max = 2000,min = 10;
            //线程随机睡眠时间
            int sleepTime = (int) (Math.random()*(max-min)+min);
            Thread.sleep(sleepTime);
            System.out.println("第"+i+"次 执行,睡眠 "+sleepTime+"毫秒");
            return true;
        }
    
        @Test
        public void test(){
    
            List<Callable<Boolean>> threadsTaskList = new ArrayList<>();
    
            for (int i = 0;i < 10 ;i++){
    
                int finalI = i;
                Callable<Boolean> curTheadTask =
                                () -> {
                                    submit(finalI);
                                    return true;
                                };
                threadsTaskList.add(curTheadTask);
            }
            try {
                List<Future<Boolean>> futures = ioPoolExecutor.invokeAll(threadsTaskList);
                for (Future<Boolean> future : futures) {
                    future.get();
                }
            } catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("线程全部执行完毕");
        }

    结果输出

    第6次 执行,睡眠 23毫秒
    第1次 执行,睡眠 64毫秒
    第5次 执行,睡眠 141毫秒
    第7次 执行,睡眠 279毫秒
    第3次 执行,睡眠 1183毫秒
    第0次 执行,睡眠 1384毫秒
    第2次 执行,睡眠 1425毫秒
    第8次 执行,睡眠 1856毫秒
    第4次 执行,睡眠 1899毫秒
    第9次 执行,睡眠 1939毫秒
    线程全部执行完毕

     

    展开全文
  • java 等待线程/线程池执行完毕

    千次阅读 2017-08-07 15:43:54
    1.单线程开始并执行完毕 当线程开始后,需要用到join的方法 不废话直接贴代码 public static void main(String args[]) { long begin = System.currentTimeMillis(); System.out.println(begin); Thread thread...

    1.单线程开始并执行完毕
    当线程开始后,需要用到join的方法
    不废话直接贴代码

       public static void main(String args[]) {
            long begin = System.currentTimeMillis();
            System.out.println(begin);
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("111");
                }
            });
            try {
                thread.start();
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println(end-begin);
            System.out.println("执行完毕");
        }

    运行结果:

    1502091332017
    111
    1002
    执行完毕

    现在我们来看一下join这个方法

        /**
         * Waits for this thread to die.
         *
         * <p> An invocation of this method behaves in exactly the same
         * way as the invocation
         *
         * <blockquote>
         * {@linkplain #join(long) join}{@code (0)}
         * </blockquote>
         *
         * @throws  InterruptedException
         *          if any thread has interrupted the current thread. The
         *          <i>interrupted status</i> of the current thread is
         *          cleared when this exception is thrown.
         */
        public final void join() throws InterruptedException {
            join(0);
        }
        翻译为中文大意就是,等待线程执行完毕!

    2.等待线程池执行完毕
    等待线程池执行完毕我们需要用到
    CountDownLatch这个类
    且看代码:

        public static void main(String args[]) throws InterruptedException {
            final CountDownLatch count = new CountDownLatch(3);
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
            try {
                long begin = System.currentTimeMillis();
                System.out.println(begin);
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(1000L);
                            count.countDown();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("111");
                    }
                });
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(2000L);
                            count.countDown();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("222");
                    }
                });
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(3000L);
                            count.countDown();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("333");
                    }
                });
    
                count.await();
                long end = System.currentTimeMillis();
                System.out.println(end-begin);
                System.out.println("执行完毕");
            } finally {
                fixedThreadPool.shutdown();
            }
        }

    最后一定要记得线程池关闭, 要不会出大问题的
    运行结果:

    1502091739441
    111
    222
    333
    3002
    执行完毕
    展开全文
  • Java 判断线程池 执行完毕

    千次阅读 2014-04-14 20:10:36
    工作中,遇到很多情况需要使用线程,或者线程池。但往往我们需要dengda

    工作中,遇到很多情况需要使用线程,或者线程池。但往往我们需要等待线程池执行结束后,使用执行结束后的数据做下一步操作。

    很多人提供的轮询,这样无形增加服务器的压力。

    现在使用JDK 1.5 提供线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的实现,可以来进行异步计算

    Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。就相当于下了一张订货单,一段时间后可以拿着提订单来提货,这期间可以干别的任何事情。其中Future 接口就是订货单,真正处理订单的是Executor类,它根据Future接口的要求来生产产品。

    Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果,也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

    Future接口是一个泛型接口,严格的格式应该是Future<V>,其中V代表了Future执行的任务返回值的类型。 Future接口的方法介绍如下:

    • boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束
    • boolean isCancelled () 任务是否已经取消,任务正常完成前将其取消,则返回 true
    • boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true
    • get () throws InterruptedException, ExecutionException  等待任务执行结束,然后获得V类型的结果。InterruptedException 线程被中断异常, ExecutionException任务执行异常,如果任务被取消,还会抛出CancellationException
    • get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样,多了设置超时时间。参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计算超时,将抛出TimeoutException
    • void shutdown(); //停止线程
    • <T> Future<T> submit(Callable<T> task);

    Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。FutureTask类同时又实现了Runnable接口,所以可以直接提交给Executor执行。

    package Thread;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class TestThread {
        public static void main(String[] args) {
            TestThread t =new TestThread();
            t.Test();
        }
        
        public void Test(){
            ExecutorService executorService = Executors.newFixedThreadPool(10);//线程池的大小
            List<Future<List<Integer>>> results = new ArrayList<Future<List<Integer>>>();//具体创建的线程对象
            for (int i =0; i< 4; i++) {
                ThreadObject v = new ThreadObject(i);
                Future<List<Integer>> result = executorService.submit(v);//执行线程
                results.add(result);//将此线程添加到线程list中
            }
            for(Future<List<Integer>> result : results){
                List<Integer> list = new ArrayList<Integer>();
                try {
                    list = result.get();//通过GET 获取线程的执行结果,如果没有执行结束,则此get方法会处于等待状态,知道线程执行结束
                } catch (Exception e) {
                }
                System.out.println(list.toString());
                System.out.println("END");
            }
            executorService.shutdown();//这里,则线程池中的线程都已经执行完毕了。所以关闭线程池
        }
    }
    

    package Thread;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    
    public class ThreadObject implements Callable<List<Integer>>{
        private int i;
        
        public ThreadObject(int i) {
            this.i = i;
            System.out.println("This is " + i);
        }
    
        @Override
        public List<Integer> call() throws Exception {
            List<Integer> list = new ArrayList<Integer>();
            for (int i =0; i< 10; i++) {
                list.add(i);
                System.out.println(this.i + " Thread: " + i);
                //Thread.sleep(100);
            }
            
            return list;
        }
    
    }
    

    展开全文
  • 主要介绍了Java判断线程池线程是否执行完毕,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java 判断线程池所有任务是否执行完毕的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • C#线程池 所有线程运行完毕

    热门讨论 2012-07-31 23:59:52
    C#线程池 所有线程运行完毕,只是测试代码,用来弄清楚,打印信息很明确,适合初学者
  • 有个需求 1.单个任务放到线程池里去运行 2.任务运行完毕之后把自己重新塞回到线程池 3.外部信号决定单个任务是否停止将自己塞回线程池 应该是用定长线程池
  • 作者 | 磊哥来源 | Java面试真题解析(ID:aimianshi666)转载请联系授权(微信ID:GG_Stone)很多场景下,我们需要等待线程池的所有任务都执行完,然后再进行下一步操作。对于线程 Thread 来说,很好实现,加一个 ...
  • (由于多线程是在不同的时候执行数据),假如执行线程池后,在执行主线程,这就涉及到线程优先级。所以会比较蛮烦。 import java.util.*; import java.util.concurrent.CountDownLatch; public class Te...
  • 背景在Java开发中,如果涉及多线程,会经常使用到线程池,本期不额外讲述线程池本身相关的东西。考虑一种场景,如果我们提交...因此,类似情况下,需要等线程池中已有任务尽量执行完毕,来避免带来意料以外的问题。...
  • CountDownLatch实现主线程等待线程池中所有线程执行完之后再执行
  • 在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的...
  • 最近一个需求需要多...这里需要判断线程池中的线程是否全部执行完毕。 一、方式一: 说明: pool.isShutDown():当调用shutdown()或shutdownNow()方法后返回为true。 pool.isTerminated():当调用shutdown()方法...
  • shutdownvoidshutdown()启动一次顺序关闭,执行以前提交的任务,但不接受新任务。如果已经关闭,则调用没有其他作用。抛出:RuntimePermission("modifyThread")),或者安全管理器的checkAccess方法拒绝访问。...
  • boolean loop = true; do{ loop=!executorService.awaitTermination(2, TimeUnit.SECONDS); }while(loop); 转载于:https://www.cnblogs.com/xxx-xxx/p/7771959.html
  • 1.根据线程池中的总线程数目等于完成的线程数目package com.luna.thread; import java.util.Random; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import ...
  • 但是,我们往往有这样的需要:要求在线程池中的任务都完成后才能执行后续的任务,或者需要任务都完成后释放资源或向数据库写入状态。这些都需要我们判断线程池的任务是否都已经完成。 判断线程池中的任务是否全部...
  • Java线程池: 等待所有线程执行完成

    千次阅读 2020-12-25 15:40:08
    需要获取多个结果, 并进行运算, 想通过线程池增加结果获取速度, 且所有结果获取后, 可以继续计算并统一返回。 依赖 <!-- https://mvnrepository.com/artifact/com.google.guava/guava --> <dependency> ...
  • http://www.cnblogs.com/pengineer/p/5011965.html 对于经常使用第三方框架进行...但是,最近做文档批量上传同步时发现线程池中的所有任务执行完毕后,线程并没有停止,然后做了一个测试,发现确实如此: 问题及...
  • 那么如果线程池嵌入在业务代码中,如何正确的等待线程池执行完,在执行后续操作呢?或者想要获取执行结果有应该怎么处理呢? 下面走一下场景: package com.example.demo1.entity; /** * create by c-pown on ...
  • 1.先执行一次shutdown()方法把所有的线程按顺序关闭,并执行未完成的线程,之后关闭 2.在主线程里循环去判断所有任务是否完成(设置一个延迟,这样不会太耗资源,当然延迟设的越小肯定出现结果越准确啊),完成则打印完成...
  • 如何等待java线程池中所有任务完成

    千次阅读 2021-02-27 22:43:03
    一、等待线程池所有线程完成:有时候我们需要等待java thread pool中所有任务完成后再做某些操作,如想要等待所有任务完成,仅需调用threadPool.awaitTermination()方法即可,请查看如下代码:ExecutorService ...
  • Java线程池任务执行完毕后回收线程

    万次阅读 2019-02-27 15:54:27
    Java线程池任务执行完毕后回收线程 线程池中的所有任务执行完毕后,线程并没有停止,导致JVM出现OOM问题。后来查找了下面链接的资料,解决问题。 ref: http://www.cnblogs.com/pengineer/p/5011965.html 问题及现象:...
  • Java线程池执行流程(源码解读) 一.背景介绍 java中,如果每个请求都创建一个新线程,开销是相当大的,服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源...
  • } } videoCheckService 的 videoCheck方法相当于是执行子线程逻辑的一个方法,使用了线程池注解@Async。 大体逻辑就是每个子线程方法都会有一个返回对象Future,然后主线程代码逻辑里有一个while循环再一直判断所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,765
精华内容 31,906
关键字:

线程池执行完毕

友情链接: 231744170826247.rar