精华内容
下载资源
问答
  • 一个定时服务,要同时开启3个线程。但是要其中指定的2个线程结束后程序才能继续后面的操作。用什么方法阻塞,并判断线程结束最好?
  • 并发编程 多核编程 线程池 ExecutorService的判断线程结束 ExecutorService并没有提供什么 isDone()或者isComplete()之类的方法。 作者Attilax 艾龙, EMAIL:1466519819@qq.com  来源:attilax的专栏 ...
    PAIP.并发编程 多核编程 线程池 ExecutorService的判断线程结束
    


    ExecutorService并没有提供什么 isDone()或者isComplete()之类的方法。


    作者Attilax  艾龙,  EMAIL:1466519819@qq.com 
    来源:attilax的专栏
    地址:http://blog.csdn.net/attilax


    解决:
    1.需要自己扩展一哈...继承一哈.
    2.添加一个制成的flag...


    try {
    es.awaitTermination(3, TimeUnit.HOURS);
    threadPoosIsComplete = true;
    } catch (InterruptedException e) {


    e.printStackTrace();
    }


    另外一个thread..invoke
    if (threadPoosIsComplete && Sqlqueue.size() == 0) {








    参考:
    Java线程池ExecutorService的newFixedThreadPool的线程状态的判断 « J2EE开发爱好者.htm
    展开全文
  • C# 判断线程是否结束Alive

    千次阅读 2019-02-15 22:07:45
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; ...namespace _5006_判断线程是否结束Alive { class UsingIsAlive ...
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Threading;
    
    namespace _5006_判断线程是否结束Alive
    {
        class UsingIsAlive
        {
            static void Main()//IsAlive 是否是活动线程,不是死线程
            {
                UsingIsAlive myUsingIsAlive = new UsingIsAlive();
                Thread myThread = new Thread
                (new ThreadStart(myUsingIsAlive.justSleep));
                myThread.Start();//执行justSleep()
                do
                {
                    Thread.Sleep(1000);//让主线程停止1秒再执行
                    Console.WriteLine
                           ("myThread 线程目前状态: {0} ",
                        myThread.IsAlive.ToString());
                    Console.WriteLine("...........");
    
                } while (myThread.IsAlive);//线程存活的时候循环执行,否则退出当前,执行下面的代码
                Console.WriteLine
                           ("开始阻止当前线程 ");
                myThread.Join();//暂停当前线程,执行justSleep(),但发现justSleep()已经结束
                Console.WriteLine
                    ("myThread 线程结束 !!:{0} ", myThread.IsAlive);
                Console.ReadLine();
                //justSleep()暂停n秒,暂停的过程中判断其所在线程的状态
    
            }
            void justSleep()
            {
                Console.WriteLine("开始启动线程的执行!!");
                Console.WriteLine("暂停线程myThread 执行10秒!!");
                Console.WriteLine("========================================");
                Thread.Sleep(10000);//停止10秒
                //int i = 0;
            }
        }
    }
    

    如上描述如有不懂,或想学习更多技术知识,可以扫码关注麒琳技术栈公众号,欢迎在线咨询

    展开全文
  • 多线程---java判断线程结束

    万次阅读 2016-10-25 16:00:36
    需求应用场景方法一isTerminatedshutdownvoid ...抛出:SecurityException - 如果安全管理器存在并且关闭,此 ExecutorService 可能操作某些不允许调用者修改的线程(因为它没有保持RuntimePermission("modifyThread




    需求应用场景

    我们多线程抓取数据或者多线程执行任务时,有时候需要多线程执行完后      才能执行其他的任务。

    这种情况下  我们就需要判断多线程什么时候执行完。有以下几种方法(推荐方法二)





    方法一 isTerminated

    使用isTerminated来判断所有任务都已完成,会返回true。但是前提是启用shutdown顺序关闭。

    shutdown

    void shutdown()
    启动一次顺序关闭,执行以前提交的任务,但不接受新任务。如果已经关闭,则调用没有其他作用。
    抛出:
    SecurityException - 如果安全管理器存在并且关闭,此 ExecutorService 可能操作某些不允许调用者修改的线程(因为它没有保持RuntimePermission("modifyThread")),或者安全管理器的 checkAccess 方法拒绝访问。


    isTerminated

    boolean isTerminated()
    如果关闭后所有任务都已完成,则返回 true。注意,除非首先调用 shutdown 或 shutdownNow,否则 isTerminated 永不为 true。
    返回:
    如果关闭后所有任务都已完成,则返回 true





    使用例子

    先调用shundown再调用isTerminated判断

    /**
     * 采用线程池开启多个子线程,主线程等待所有的子线程执行完毕  
     */  
    public static void moreThread() {  
        try {  
            int threadNum = 0;  
            for (int i = 0; i < 10; i++) {  
                threadNum++;  
                  
                final int currentThreadNum = threadNum;  
                exe.execute(new Runnable() {  
                      
                    @Override  
                    public void run() {  
                        try {  
                            System.out.println("子线程[" + currentThreadNum + "]开启");  
                            Thread.sleep(1000*10);  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }finally{  
                            System.out.println("子线程[" + currentThreadNum + "]结束");  
                        }  
                    }  
                });    
            }  
              
            System.out.println("已经开启所有的子线程");  
            exe.shutdown();  
            System.out.println("shutdown():启动一次顺序关闭,执行以前提交的任务,但不接受新任务。");  
            while(true){  
                if(exe.isTerminated()){  
                    System.out.println("所有的子线程都结束了!");  
                    break;  
                }  
                Thread.sleep(1000);    
            }  
              
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }finally{  
            System.out.println("主线程结束");  
        }  
    }  



    输出结果

    子线程[1]开启  
    子线程[6]开启  
    子线程[2]开启  
    子线程[5]开启  
    子线程[9]开启  
    已经开启所有的子线程  
    子线程[3]开启  
    子线程[7]开启  
    子线程[10]开启  
    shutdown():启动一次顺序关闭,执行以前提交的任务,但不接受新任务。  
    子线程[4]开启  
    子线程[8]开启  
    子线程[6]结束  
    子线程[3]结束  
    子线程[7]结束  
    子线程[2]结束  
    子线程[1]结束  
    子线程[5]结束  
    子线程[9]结束  
    子线程[4]结束  
    子线程[10]结束  
    子线程[8]结束  
    所有的子线程都结束了!  
    主线程结束







    方法二CountDownLatch

    CountDownLatch是一个同步辅助类,用来判断多线程是否执行完成。

    它的原理是首先声明一共运行多少个线程任务,然后每完成一个线程任务,计数器就减一,当计数器等于0,说明所有的多线程都运行完成了。


    主要方法

     public CountDownLatch(int count);
     public void countDown();
     public void await() throws InterruptedException
     
    构造方法参数指定了计数的次数
    countDown方法,当前线程调用此方法,则计数减一
    await方法,调用此方法会一直阻塞当前线程,直到计时器的值为0。


    使用方法

    如果你确定了你开启的线程数。 
    那么在主程序运行前。 
    CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。 

    在每个子线程结束后,调用 countdown.countDown(); 

    在主线程里启动子线程的方法后面添加。 
    countdown.await();//这里进行同步等待 

    等所有子线程结束后,执行 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 {  
            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();//  
            latch.await();//等待所有工人完成工作  
            System.out.println("all work done at "+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()));  
                latch.countDown();//工人完成工作,计数器减一  
      
            }  
              
            private void doWork(){  
                try {  
                    Thread.sleep(workTime);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
          
           
    }  
     


    输出结果

    Worker zhang san do work begin at 2011-04-14 11:05:11
    Worker li si do work begin at 2011-04-14 11:05:11
    Worker zhang san do work complete at 2011-04-14 11:05:16
    Worker li si do work complete at 2011-04-14 11:05:19
    all work done at 2011-04-14 11:05:19







    方法三CyclicBarrier

    CyclicBarrier ,一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。CyclicBarrier 支持一个可选的 Runnable 命令,在一组线程中的最后一个线程到达之后(但在释放所有线程之前),该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态,此屏障操作 很有用。 


    主要方法

    //设置parties、count及barrierCommand属性。
    CyclicBarrier(int):

    //当await的数量到达了设定的数量后,首先执行该Runnable对象。
    CyclicBarrier(int,Runnable):

    //通知barrier已完成线程
    await():







    使用例子

    我们需要统计全国的业务数据。其中各省的数据库是独立的,也就是说按省分库。并且统计的数据量很大,统计过程也比较慢。为了提高性能,快速计算。我们采取并发的方式,多个线程同时计算各省数据,最后再汇总统计。在这里CyclicBarrier就非常有用。看代码: 
    主要类:
    /**  
     * 各省数据独立,分库存偖。为了提高计算性能,统计时采用每个省开一个线程先计算单省结果,最后汇总。  
     *   
     * @author guangbo email:weigbo@163.com  
     *   
     */  
    public class Total {     
        // private ConcurrentHashMap result = new ConcurrentHashMap();   
      
        public static void main(String[] args) {   
            TotalService totalService = new TotalServiceImpl();   
            CyclicBarrier barrier = new CyclicBarrier(5,   
                    new TotalTask(totalService));   
      
            // 实际系统是查出所有省编码code的列表,然后循环,每个code生成一个线程。   
            new BillTask(new BillServiceImpl(), barrier, "北京").start();   
            new BillTask(new BillServiceImpl(), barrier, "上海").start();   
            new BillTask(new BillServiceImpl(), barrier, "广西").start();   
            new BillTask(new BillServiceImpl(), barrier, "四川").start();   
            new BillTask(new BillServiceImpl(), barrier, "黑龙江").start();   
      
        }   
    }   
      
    /**  
     * 主任务:汇总任务  
     */  
    class TotalTask implements Runnable {   
        private TotalService totalService;   
      
        TotalTask(TotalService totalService) {   
            this.totalService = totalService;   
        }   
      
        public void run() {   
            // 读取内存中各省的数据汇总,过程略。   
            totalService.count();   
            System.out.println("=======================================");   
            System.out.println("开始全国汇总");   
        }   
    }   
      
    /**  
     * 子任务:计费任务  
     */  
    class BillTask extends Thread {   
        // 计费服务   
        private BillService billService;   
        private CyclicBarrier barrier;   
        // 代码,按省代码分类,各省数据库独立。   
        private String code;   
      
        BillTask(BillService billService, CyclicBarrier barrier, String code) {   
            this.billService = billService;   
            this.barrier = barrier;   
            this.code = code;   
        }   
      
        public void run() {   
            System.out.println("开始计算--" + code + "省--数据!");   
            billService.bill(code);   
            // 把bill方法结果存入内存,如ConcurrentHashMap,vector等,代码略   
            System.out.println(code + "省已经计算完成,并通知汇总Service!");   
            try {   
                // 通知barrier已经完成   
                barrier.await();   
            } catch (InterruptedException e) {   
                e.printStackTrace();   
            } catch (BrokenBarrierException e) {   
                e.printStackTrace();   
            }   
        }   
      
    } 

     

    输出结果

    开始计算--北京省--数据! 
    开始计算--上海省--数据! 
    北京省已经计算完成,并通知汇总Service! 
    开始计算--四川省--数据! 
    四川省已经计算完成,并通知汇总Service! 
    上海省已经计算完成,并通知汇总Service! 
    开始计算--广西省--数据! 
    广西省已经计算完成,并通知汇总Service! 
    开始计算--黑龙江省--数据! 
    黑龙江省已经计算完成,并通知汇总Service! 



    展开全文
  • 如何判断线程运行结束

    千次阅读 2019-05-05 11:03:42
    此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完 3.线程池ThreadPoolExecutor的shutdown与awaitTermination方法 executor.shutdown();//只是不能再提交新任务,...

    1.join()
    如果是一个线程,可以使用此方法,多个不合适
    2.CountDownLatch
    此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完

    3.线程池ThreadPoolExecutor的shutdown与awaitTermination方法

    executor.shutdown();//只是不能再提交新任务,等待执行的任务不受影响  
    
    try {  
            boolean loop = true;  
            do {    //等待所有任务完成  
                loop = !executor.awaitTermination(2, TimeUnit.SECONDS);  //阻塞,直到线程池里所有任务结束
            } while(loop);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } 
    
    service.shutdown();  
    
    while(!service.awaitTermination(2, TimeUnit.SECONDS)){  
    
            System.out.println("service not stop"); 
    
        }  
    
    
    //或者isTerminated,如果关闭后所有任务都已完成,则返回 true。注意,除非首先调用 shutdown 或 shutdownNow,否则 isTerminated 永不为 true。
    
    executor.shutdown();//只是不能再提交新任务,等待执行的任务不受影响  
    
    while(true){  
            if(exe.isTerminated()){ 
                System.out.println("所有的子线程都结束了!");  
                break;  
            }  
            Thread.sleep(1000);    
        }  
    

    ThreadPoolExecutor.getActiveCount() == 0 ?

    展开全文
  • 易语言判断线程是否运行结束源码,判断线程是否运行结束,子程序1
  • ![图片说明]...!...我把一个list分为了10份,开启了10个线程同时查询,把结果add到了sorankgridlist里, 现在我想在全部线程结束后,把sorankgridlist存进数据库,该怎么写,求教
  • 易语言判断多个线程运行结束源码,判断多个线程运行结束,子程序1
  • 线程存在的判断是用pthread_kill(threadid,0),是指线程的ID还存在吗,如果没有用pthread_join来回收结束线程线程的ID不是还存在吗,那么他判断的标准是什么?
  • 如何判断线程是否都结束

    万次阅读 2019-02-25 14:34:29
    方法1:通过Thread类中的isAlive()方法判断线程是否处于活动状态。 线程启动后,只要没有运行完毕,都会返回true。 【注】如果只是要等其他线程运行结束之后再继续操作,可以执行t.join(),即:在t执行完毕前挂起...
  • C# 中如何判断线程是否结束

    千次阅读 2011-02-25 12:29:06
    可喜的是微软提供了我们这样一个方法,IsAlive()其判断线程是否还在运行状态,所以我们可以在循环中一直判断这个标识,等该线程结束后,退出线程。而我们的程序在执行过程中,可能又要判断是否...
  • MFC 判断线程是否结束

    千次阅读 2013-04-14 11:32:18
    功能: 获取一个结束线程的返回值 函数原形: BOOL GetExitCodeThread( HANDLE hThread, LPDWORD lpExitCode); 参数: hThread 指向欲获取返回值的线程对象的句柄  lpExitCode 用于存储线程的返回值...
  • 判断线程是否结束的方法

    千次阅读 2013-03-18 16:12:48
    原文链接:判断线程是否结束的方法 1、 GetExitCodeThread  比较原始的方法了,调用 GetExitCodeThread,如果返回STILL_ACTIVE,那就是还在运行,否则,会返回退出代码.  该方法的优点是除了可以判断...
  • 判断线程是否已经结束

    千次阅读 2019-04-07 16:50:06
    一代码 #include <iostream> #include <pthread.h> #include <signal.h> #include <unistd.h> //sleep #include "errno.h" ...void *thfunc(void *arg) // 线程函数...
  • Java判断线程是否结束

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

    千次阅读 2006-09-13 21:09:26
    为了测试获取网页源码,使用C#...在编程的过程中,在主线程中启动了多个线程后,往往想等线程结束后再打印一些统计信息出来,但是可能先执行主线程中的打印语句,后面线程才能结束,这往往不是我们想要的。而如何判...
  • 易语言源码易语言判断线程是否运行结束源码.rar
  • 易语言源码易语言判断多个线程运行结束源码.rar
  • 易语言判断线程是否运行结束源码
  • 易语言判断多个线程运行结束源码
  • 此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完 public class ImportThread extends Thread { private CountDownLatch threadsSignal; public ImportThread...
  • 在delphi中如何判断线程终止

    千次阅读 2010-08-29 00:25:00
    Obj: TQueryThread 用delphi的TThread类实现 用什么方法可知线程结束了,我用线程句柄,有的线程结束了,但句柄不是0 请问用什么方法判断线程结束了?然后重启结束的线程 楼上的一些方法...
  • 判断@Async注解下所有线程是否结束

    千次阅读 2020-01-12 11:18:38
    因为在项目中想知道程序运行的时间,百度都只有判断线程结束的方法,所以记录下自己的解决方案 **//这是一个带有回调的多线程函数** @Async public Future<String> getWaterValveInfo(String tableName) { ...
  • 易语言大漠多线程模板多线程结束

    千次阅读 2020-06-02 09:06:06
    为了在线程结束时保证线程安全,首先采用WaitForSingleObject自然等待结束,设置了30s的等待时间,当自然结束失败时,如果等待自然线程失败,没有办法的情况下,只能强制粗暴的结束线程,同时我们对象对计数器进行...
  • 这样就会碰到一个问题,当你开启线程,在线程没有运行完的时候,想要结束这个线程,要怎么操作呢? 标志位结束线程 这是一种我们很容易理解的结束方式。设置一个标志位,当你想要结束线程的时候,就把这个标志位的...
  • 一直没弄明白异步执行的线程之间,如果一个线程要等待其它必要的线程先完成才能继续执行这个线程的话,该如何做呢?直到到论坛问了一些大神,才得到点启示。形成实例,却又状况百出。直到今天,终于弄出想要的效果了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 277,559
精华内容 111,023
关键字:

判断线程结束