精华内容
下载资源
问答
  • 2017-12-07 10:59:23

    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,我需要在所有的子线程写入完毕后在文件末尾写“---END---”及关闭文件流等,这个时候我就需要某个标志位可以告诉我是否线程池中所有的子线程都已经执行完毕,我使用这种方式来判断。

    public class MySemaphore {
    
        public static void main(String[] args) throws IOException, InterruptedException {
            final File stream = new File("c:\\temp\\stonefeng\\stream.txt");
            final OutputStream os = new FileOutputStream(stream);
            final OutputStreamWriter writer = new OutputStreamWriter(os);
            final Semaphore semaphore = new Semaphore(10);
            ExecutorService exec = Executors.newCachedThreadPool();
            
            final long start = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                final int num = i;
                Runnable task = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            semaphore.acquire();
                            writer.write(String.valueOf(num)+"\n");
                            semaphore.release();
                        } catch (IOException e) {
                            e.printStackTrace();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                exec.submit(task);
            }
            exec.shutdown();
            while(true){  
               if(exec.isTerminated()){  
                    writer.write("---END---\n");
                    writer.close();
                    System.out.println("所有的子线程都结束了!");  
                    break;  
                }  
                Thread.sleep(1000);    
            }
            final long end = System.currentTimeMillis();
            System.out.println((end-start)/1000);
        }
    }

    当调用ExecutorService.shutdown方法的时候,线程池不再接收任何新任务,但此时线程池并不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。在调用shutdown方法后我们可以在一个死循环里面用isTerminated方法判断是否线程池中的所有线程已经执行完毕,如果子线程都结束了,我们就可以做关闭流等后续操作了。

    判断线程池中的线程是否全部执行完毕的另外一种解决方案则是使用闭锁(CountDownLatch)来实现,CountDownLatch是一种灵活的闭锁实现,它可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器,该计数器被初始化为一个正数,表示需要等待的事件数量。countDown方法递减计数器,表示有一个事件已经发生了,而await方法等待计数器达到零,即表示需要等待的事情都已经发生。可以使用闭锁来这样设计程序达到目的:

    public class CountDownLatchApproach {
        public static void main(String[] args) throws IOException, InterruptedException {
            final int nThreads = 10;
            final CountDownLatch endGate = new CountDownLatch(nThreads);
            final File stream = new File("c:\\temp\\stonefeng\\stream.txt");
            final OutputStream os = new FileOutputStream(stream);
            final OutputStreamWriter writer = new OutputStreamWriter(os);
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i < nThreads; i++) {
                final int num = i;
                Runnable task = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            writer.write(String.valueOf(num)+"\n");
                        } catch (IOException e) {
                            e.printStackTrace();
                        } finally {
                            endGate.countDown();
                        }
                    }
                };
                exec.submit(task);
            }
            endGate.await();
            writer.write("---END---\n");
            writer.close();
        }
    }

    这种解决方案虽然可以达到目的但是性能差到没朋友,我更倾向于使用第一种方案。

    现在我们有了更优雅的第三种方案,它的执行性能也不错。

    public class MySemaphore {
    
        public static void main(String[] args) throws IOException, InterruptedException {
            final File stream = new File("c:\\temp\\stonefeng\\stream.txt");
            final OutputStream os = new FileOutputStream(stream);
            final OutputStreamWriter writer = new OutputStreamWriter(os);
            final Semaphore semaphore = new Semaphore(10);
            ExecutorService exec = Executors.newCachedThreadPool();
            
            final long start = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                final int num = i;
                Runnable task = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            semaphore.acquire();
                            writer.write(String.valueOf(num)+"\n");
                            semaphore.release();
                        } catch (IOException e) {
                            e.printStackTrace();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                exec.submit(task);
            }
            exec.shutdown();
            exec.awaitTermination(1, TimeUnit.HOURS);
            writer.write("---END---\n");
            writer.close();
            System.out.println("ËùÓеÄ×ÓÏ̶߳¼½áÊøÁË£¡");  
            final long end = System.currentTimeMillis();
            System.out.println((end-start)/1000);
        }
    }





    更多相关内容
  • 主要介绍了Java判断线程池线程是否执行完毕,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了判断Threading.start新线程是否执行完毕的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 易语言判断多线程是否运行结束源码,判断多线程是否运行结束,子程序1
  • 在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的...

    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,我需要在所有的子线程写入完毕后在文件末尾写“---END---”及关闭文件流等,这个时候我就需要某个标志位可以告诉我是否线程池中所有的子线程都已经执行完毕,我使用这种方式来判断。

    public classMySemaphore {

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

    final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    final OutputStream os = newFileOutputStream(stream);

    final OutputStreamWriter writer = newOutputStreamWriter(os);

    final Semaphore semaphore = new Semaphore(10);

    ExecutorService exec =Executors.newCachedThreadPool();

    final long start =System.currentTimeMillis();

    for (int i = 0; i < 10000000; i++) {

    final int num =i;

    Runnable task = newRunnable() {

    @Override

    public voidrun() {

    try{

    semaphore.acquire();

    writer.write(String.valueOf(num)+"\n");

    semaphore.release();

    } catch(IOException e) {

    e.printStackTrace();

    } catch(InterruptedException e) {

    e.printStackTrace();

    }

    }

    };

    exec.submit(task);

    }

    exec.shutdown();while(true){

    if(exec.isTerminated()){

    writer.write("---END---\n");

    writer.close();

    System.out.println("所有的子线程都结束了!");

    break;

    }

    Thread.sleep(1000);

    }final long end =System.currentTimeMillis();

    System.out.println((end-start)/1000);

    }

    }

    当调用ExecutorService.shutdown方法的时候,线程池不再接收任何新任务,但此时线程池并不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。在调用shutdown方法后我们可以在一个死循环里面用isTerminated方法判断是否线程池中的所有线程已经执行完毕,如果子线程都结束了,我们就可以做关闭流等后续操作了。

    判断线程池中的线程是否全部执行完毕的另外一种解决方案则是使用闭锁(CountDownLatch)来实现,CountDownLatch是一种灵活的闭锁实现,它可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器,该计数器被初始化为一个正数,表示需要等待的事件数量。countDown方法递减计数器,表示有一个事件已经发生了,而await方法等待计数器达到零,即表示需要等待的事情都已经发生。可以使用闭锁来这样设计程序达到目的:

    1 public classCountDownLatchApproach {

    2 public static void main(String[] args) throwsIOException, InterruptedException {

    3 final int nThreads = 10;

    4 final CountDownLatch endGate = new CountDownLatch(nThreads);5 final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    6 final OutputStream os = newFileOutputStream(stream);

    7 final OutputStreamWriter writer = newOutputStreamWriter(os);

    8 ExecutorService exec =Executors.newCachedThreadPool();

    9 for (int i = 0; i < nThreads; i++) {

    10 final int num =i;

    11 Runnable task = newRunnable() {

    12 @Override

    13 public voidrun() {

    14 try{

    15 writer.write(String.valueOf(num)+"\n");

    16 } catch(IOException e) {

    17 e.printStackTrace();

    18 } finally{

    19 endGate.countDown();20 }

    21 }

    22 };

    23 exec.submit(task);

    24 }

    25 endGate.await();26 writer.write("---END---\n");

    27 writer.close();

    28 }

    29 }

    这种解决方案虽然可以达到目的但是性能差到没朋友,我更倾向于使用第一种方案。

    现在我们有了更优雅的第三种方案,它的执行性能也不错。

    1 public classMySemaphore {

    2

    3 public static void main(String[] args) throwsIOException, InterruptedException {

    4 final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    5 final OutputStream os = newFileOutputStream(stream);

    6 final OutputStreamWriter writer = newOutputStreamWriter(os);

    7 final Semaphore semaphore = new Semaphore(10);

    8 ExecutorService exec =Executors.newCachedThreadPool();

    9

    10 final long start =System.currentTimeMillis();

    11 for (int i = 0; i < 10000000; i++) {

    12 final int num =i;

    13 Runnable task = newRunnable() {

    14 @Override

    15 public voidrun() {

    16 try{

    17 semaphore.acquire();

    18 writer.write(String.valueOf(num)+"\n");

    19 semaphore.release();

    20 } catch(IOException e) {

    21 e.printStackTrace();

    22 } catch(InterruptedException e) {

    23 e.printStackTrace();

    24 }

    25 }

    26 };

    27 exec.submit(task);

    28 }

    29 exec.shutdown();

    30 exec.awaitTermination(1, TimeUnit.HOURS);31 writer.write("---END---\n");

    32 writer.close();

    33 System.out.println("ËùÓеÄ×ÓÏ̶߳¼½áÊøÁË£¡");

    34 final long end =System.currentTimeMillis();

    35 System.out.println((end-start)/1000);

    36 }

    37 }

    展开全文
  • 判断多线程是否全部执行完毕

    千次阅读 2017-02-13 20:30:59
    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的...

    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,我需要在所有的子线程写入完毕后在文件末尾写“---END---”及关闭文件流等,这个时候我就需要某个标志位可以告诉我是否线程池中所有的子线程都已经执行完毕,我使用这种方式来判断。

    复制代码
    public class MySemaphore {
    
        public static void main(String[] args) throws IOException, InterruptedException {
            final File stream = new File("c:\\temp\\stonefeng\\stream.txt");
            final OutputStream os = new FileOutputStream(stream);
            final OutputStreamWriter writer = new OutputStreamWriter(os);
            final Semaphore semaphore = new Semaphore(10);
            ExecutorService exec = Executors.newCachedThreadPool();
            
            final long start = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                final int num = i;
                Runnable task = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            semaphore.acquire();
                            writer.write(String.valueOf(num)+"\n");
                            semaphore.release();
                        } catch (IOException e) {
                            e.printStackTrace();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                exec.submit(task);
            }
            exec.shutdown();
            while(true){  
               if(exec.isTerminated()){  
                    writer.write("---END---\n");
                    writer.close();
                    System.out.println("所有的子线程都结束了!");  
                    break;  
                }  
                Thread.sleep(1000);    
            }
            final long end = System.currentTimeMillis();
            System.out.println((end-start)/1000);
        }
    }
    复制代码

    当调用ExecutorService.shutdown方法的时候,线程池不再接收任何新任务,但此时线程池并不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。在调用shutdown方法后我们可以在一个死循环里面用isTerminated方法判断是否线程池中的所有线程已经执行完毕,如果子线程都结束了,我们就可以做关闭流等后续操作了。

    展开全文
  • Java判断多线程是否结束

    千次阅读 2019-03-10 08:35:14
    JAVA判断多线程是否结束应用场景主要方法实现代码 应用场景 程序中需要等待多线程任务全部执行完毕后,再执行后续操作。 主要方法 使用方法 1、确定了你开启的线程数,那么在主程序运行前。 CountDownLatch ...

    JAVA判断多线程是否结束

    应用场景

    程序中需要等待多线程任务全部执行完毕后,再执行后续操作。

    主要方法

    使用方法
    1、确定了你开启的线程数,那么在主程序运行前。
    CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。

    2、在每个子线程结束后,调用 countdown.countDown();
    当前线程调用此方法,则计数减一

    3、在主线程里启动多线程的方法后面添加:countdown.await();//这里进行同步等待
    调用此方法会一直阻塞当前线程,直到计时器的值为0。

    4、等所有子线程结束后,执行 countdown.await()后面的代码。

    实现代码

    public class CountDownLatchDemo { 
        final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
        public static void main(String[] args) throws InterruptedException {
       		//步骤1:确定开启的线程数,声明CountDownLatch对象 ,对象需要作为入参,传给多线程的构造函数
            CountDownLatch latch=new CountDownLatch(2);
            Worker worker1=new Worker("zhang san", 5000, latch); 
            Worker worker2=new Worker("li si", 8000, latch); 
            worker1.start();// 
            worker2.start();// 
            //步骤3、4、调用await放过,等待所有线程完成工作 
            latch.await();
            System.out.println("全部线程执行完毕!可以开始后续操作:" + sdf.format(new Date())); 
        } 
    
        static class Worker extends Thread{ 
            String workerName;   
            int workTime; 
            CountDownLatch latch; 
            public Worker(String workerName ,int workTime ,CountDownLatch latch){ 
                 this.workerName=workerName; 
                 this.workTime=workTime; 
                 this.latch=latch; 
            } 
            public void run(){ 
                System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date())); 
                doWork();//工作了 
                System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date())); 
                //步骤2、每个线程run方法完成工作后,将计数器减一 
                latch.countDown();
     
            } 
                 
            private void doWork(){ 
                try { 
                    Thread.sleep(workTime); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        } 
    } 
    
    展开全文
  • 判断线程池中所有线程是否执行完毕 1.根据线程池中的总线程数目等于完成的线程数目 package com.luna.thread; import java.util.Random; import java.util.concurrent.LinkedBlockingQueue; import java.util....
  • 当任务量较大时,我们需要开启线程执行任务,但是在一些特定需求下,我们需要在全部任务执行后获取执行结束标识等信息,此时就需要判断任务分配的线程是否全部结束。 目录: 四程池 判断线程是否全部执行完毕...
  • // 日前工作遇到一个需求,就是把硬盘的文件(大量文件)全部读取出来,然后全部解析生成文件保存到硬盘需要多线程处理,并要计算全部执行结束后的耗时。以下是实现方法. // 创建线程池 ExecutorService ...
  • java中怎么判断线程执行完毕

    千次阅读 2021-02-12 15:26:40
    java中怎么判断线程执行完毕发布时间:2020-05-15 15:18:05来源:亿速云阅读:316作者:Leahjava中怎么判断线程执行完毕?针对这个问题,今天小编总结这篇有关线程判断的文章,希望帮助更想学习java的同学找到更加...
  • Python多线程以及判断线程是否结束

    千次阅读 2022-04-27 11:39:19
    python,多线程,结束
  • 如果是一个线程,可以使用此方法,个不合适 2.CountDownLatch 此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完 public class ImportThread extends Thread { ...
  • 所以采用多线程抽取方式,其中 每五分钟抽一次。 创建五个线程A,B,C,D,E 其中线程A 执行的表:table 数据量特别大,导致五分钟没有抽取完毕,第二次又开始抽取了table,遇到之前线程没有抽取完的表需要跳过,本次不...
  • 最主要的还是判断十个进程是否都已结束 问题补充: 但是执行完了我用isAlive属性来判断,进程还是处于Runable 满意回答 在class ReadFileThread implements Runnable { 设置一个静态变量count public static int ...
  • 在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的...
  • Android多线程执行判断结束标志

    千次阅读 2022-02-28 13:47:54
    fun main() { val newFixedThreadPool = Executors.newFixedThreadPool(5) val start = System.currentTimeMillis() ...println("${Thread.currentThread().name}:执行结束") } newFixedThreadPool.s
  • ThreadPoolExecutor 判断多线程执行完成

    万次阅读 2017-03-07 11:13:02
    1. ...//如果线程池处理完毕,就干别的事情...,这个方法一定...在多线程中是很浪费CPU的,从而使得线程池中各个线程得到很少的CPU机会去执行自己各自的任务。因此影响了线程池的优势的发挥。 2.改进方法 ...
  • 上面是主线程的代码,创建了一个能同时执行2个线程的线程池,并投入5个线程,当5个线程都执行完毕后打印---“结束了!”字符串。 exe.shutdown();该方法在加入线程队列的线程执行完之前不会执行。 exe.is...
  •   CountDownLatch:具有计数器的功能,等待其他线程执行完毕,主线程在继续执行,用于监听某些初始化操作,并且线程进行阻塞,等初始化执行完毕后,通知主线程继续工作执行。值得注意的是CountDownLatch计数的次数...
  • 定义 ountDownLatch是在java1.5被引入,存在于java.util.cucurrent包下,跟它...每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。 线
  • 1、先来看看这个多线程编程多线程用于数据采集时,速度明显很快,下面是基本方法,把那个auto写成采集数据方法即可。 using System; using System.Collections.Generic; using System.Text; using System....
  • 线程调用案列: .版本 2 .支持库 EThread .支持库 spec .程序集 窗口程序集1 .子程序 _按钮1_被单击 .局部变量 handle, 整数型 启动线程 (&Thread, , handle) 关闭线程句柄 (handle) .子程序 Thread .局部...
  • 我尝试使用C#的task对快速排序算法进行并行化,简单的思路是:确定枢值位置后将前后两段分别交给两个不同的task并发执行,如此递归,最终能得到正确的排序结果 ...有没有方法可以判断当前所有task是否全部执行完毕

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 311,846
精华内容 124,738
关键字:

如何判断多线程是否执行完毕