精华内容
下载资源
问答
  • 如何判断线程运行结束

    千次阅读 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 ?

    展开全文
  • C#主线程等待子线程运行结束

    千次阅读 2017-11-06 20:27:00
    佐左佑右原文C#主线程等待子线程运行结束  由于主程序中调用matlab的dll文件进行计算要用较长的时间,主界面会有很长时间的卡顿,造成的用户感受十分不好,因此我想在调用时,将调用放入子线程中,然后在主线程中弹...

    佐左佑右 原文 C#主线程等待子线程运行结束

      由于主程序中调用matlab的dll文件进行计算要用较长的时间,主界面会有很长时间的卡顿,造成的用户感受十分不好,因此我想在调用时,将调用放入子线程中,然后在主线程中弹出一个提示框,显示数据正在加载,等子线程运行结束后,主线程继续工作。

        使用的是http://hi.baidu.com/oktell/item/5527f51d93abb4a5feded5a8中所提到的方法,用了这篇文章中的第一个方式,即不带参数的。
        之后在其中加入了显示和关闭提示框的代码,最终完成。代码如下:
    复制代码
    using System.Threading;
    namespace ThreadStudy { class StopAllWaitBySubThread { List manualEvents = new List(); public void Main() { ManualResetEvent mre = new ManualResetEvent(false); manualEvents.Add(mre); ThreadPool.QueueUserWorkItem(ThreadMethod, mre); Form f = Application.OpenForms["Form_CreateObject"];//查找是否打开过窗体 if (f == null) //没打开过 ,打开 { Form_CreateObject datamanage = new Form_CreateObject(); datamanage.Show(); } else { f.Focus(); //打开过就让其获得焦点 } WaitHandle.WaitAll(manualEvents.ToArray());//程序会在此处暂停,等待子线程运行结束。 f = Application.OpenForms["Form_CreateObject"];//查找是否打开过窗体 if (f == null) //没打开过 {
    }
    else { f.Close(); //打开过就关掉 } } private void ThreadMethod(object obj) { //耗时的函数,处理事情,Matlab Matlab(); ManualResetEvent mre = (ManualResetEvent)obj; mre.Set(); Console.WriteLine("Thread execute"); } } }
    复制代码

     

        经过试用后发现,UI中的等待gif还是会卡住。事实上,上述方法相当于是将主线程阻塞了,因此提示框卡住就难以避免。同时,我还发现,使用多线程后,得出结果的速度更快了,效率上有着一定的提高。
    没有整理与归纳的知识,一文不值!高度概括与梳理的知识,才是自己真正的知识与技能。 永远不要让自己的自由、好奇、充满创造力的想法被现实的框架所束缚,让创造力自由成长吧! 多花时间,关心他(她)人,正如别人所关心你的。理想的腾飞与实现,没有别人的支持与帮助,是万万不能的。


        本文转自wenglabs博客园博客,原文链接:http://www.cnblogs.com/arxive/p/5958123.html ,如需转载请自行联系原作者




    展开全文
  • C#中检测线程结束的方法有多种:  一. 使用带返回值的Func开启的线程检测:   Func f = MyThread;  IAsyncResult ar=f.BeginInvoke(3,"str参数",null,null);  fun
            C#中检测线程结束的方法有多种:

             一.        使用带返回值的Func开启的线程检测:     

                    Func<int, string,int> f = MyThread;
                   IAsyncResult ar=f.BeginInvoke(3,"str参数",null,null);

                   func对象的BeginInvoke方法会返回IAsyncResult类型的对象,此对象的IsCompleted属性用来判断线程是否完成;

             二.       通过等待句柄检测委托线程的结束;

                Func<int, string, int> fu = MyThread;
                IAsyncResult iAr = f.BeginInvoke(3, "str参数", null, null);//IAsyncResult可以获得当前线程的状态
                //检测线程结束;
                bool isEnd = iAr.AsyncWaitHandle.WaitOne(1000);

                //1000毫秒表示超时时间,如果等待1000毫秒还没有结束的话
                //就返回false,如果在1000ms内结束了就返回true;

             三.      通过回调函数检测;

               Func<int, string, int> fu = MyThread;
                IAsyncResult iAr = fu.BeginInvoke(3, "str参数", OnCallBack, fu);//IAsyncResult可以获得当前线程的状态,
                //倒数第二个参数是委托类型的参数表示回调函数,就是线程结束时会调用这个委托所指向的方法;
                //倒数第一个参数给回调函数传递数据参数


             static void OnCallBack(IAsyncResult iar)  //回调函数
            {
                Func<int, string, int> a = iar.AsyncState as Func<int, string, int>;
                int result=a.EndInvoke(iar);
                Console.WriteLine("Result:"+result);
            }

            也可以用lambda表达式来表示:

             Func<int, string, int> fu = MyThread;

             fu.BeginInvoke(3, "str参数", free=>

             {

                   int result= fu.EndInvoke(free);   

                   Console.WriteLine("Result:"+result);


              }, null)

         
    微笑  啦啦啦, 学习快乐!


           












    展开全文
  • 实际开发中,经常会碰到这种问题,某个线程需要等待所有的线程执行结束了,才可以继续执行。要实现这个效果,Java中有很多方案,下面我列举一些我所知道的方案: 方案一:join。代码如下: Thread thread1=new ...

    Java架构师交流群:793825326

    java版本:jdk1.8

    IDE:Idea2019

    实际开发中,经常会碰到这种问题,某个线程需要等待所有的线程执行结束了,才可以继续执行。要实现这个效果,Java中有很多方案,下面我列举一些我所知道的方案:

    方案一:join。代码如下:

    Thread thread1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread1 start");
                        for (int i=0;i<10;i++)
                        {
                            Thread.sleep(500);
                            System.out.println("thread1 is working");
                        }
                        System.out.println("thread1 end");
                    }
                    catch (Exception ex) {System.out.println(ex.toString());}
                }
            });
    
            Thread thread2=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread2 start");
                        for (int i=0;i<5;i++)
                        {
                            Thread.sleep(500);
                            System.out.println("thread2 is working");
                        }
                        System.out.println("thread2 end");
                    }
                    catch (Exception ex) {System.out.println(ex.toString());}
                }
            });
    
            Thread thread3=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread3 start");
    
                        System.out.println("thread3 end");
                    }
                    catch (Exception ex) {System.out.println(ex.toString());}
                }
            });
            try {
                thread1.start();
                thread2.start();
                thread1.join();
                thread2.join();
                thread3.start();
    
            }
            catch (Exception ex)
            {
                System.out.println(ex.toString());
            }
    }

    该段代码的运行结果如下:

    thread1 start
    thread2 start
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    thread1.start();
    thread2.start();
    thread1.join();
    thread3.start();
    thread2.join();

    join的作用是一个子线程加入到当前线程,并导致当前线程等待,让其中调用了join方法的子线程运行,直到子线程运行结束了才会继续往下执行,join不会阻塞代码往下执行,也就是说不会阻塞其他的线程Join,比如本例中虽然thread1.join();方法被调用了,并不妨碍thread2.join();的执行,即便你把这句代码放到thread3.start();之后:

    其运行结果仍然是一样的:

    thread2 start
    thread1 start
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    方案二:wait/notifyAll,代码如下:

    private static Object lock=new Object();
    private static final AtomicInteger count = new AtomicInteger(2);
    public static void main(String[] args) {
    
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread1 start");
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(500);
                        System.out.println("thread1 is working");
                    }
                    System.out.println("thread1 end");
                    synchronized (lock) {
                        if (count.decrementAndGet() == 0)
                            lock.notifyAll();
                    }
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
    
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("thread2 start");
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(500);
                        System.out.println("thread2 is working");
                    }
                    System.out.println("thread2 end");
                    synchronized (lock) {
                        if (count.decrementAndGet() == 0)
                            lock.notifyAll();
                    }
    
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
    
        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        lock.wait();
                    }
                    System.out.println("thread3 start");
    
                    System.out.println("thread3 end");
                } catch (Exception ex) {
                    System.out.println(ex.toString());
                }
            }
        });
        try {
            thread1.start();
            thread2.start();
            thread3.start();
        }
        catch (Exception ex)
        {
            System.out.println(ex.toString());
        }
    }

    其执行结果如下:

    thread1 start
    thread2 start
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    这方法其实本质上和加锁的区别就是把耗时的代码不加锁,然后增加一个标记量来判断是否让thread3开始执行罢了。

    方法三:CountDownLatch,代码如下:

    private static final CountDownLatch latch=new CountDownLatch(2);
        public static void main(String[] args) {
    
            Thread thread1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread1 start");
                        for (int i = 0; i < 10; i++) {
                            Thread.sleep(500);
                            System.out.println("thread1 is working");
                        }
                        System.out.println("thread1 end");
                        latch.countDown();
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread2=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread2 start");
                        for (int i = 0; i < 5; i++) {
                            Thread.sleep(500);
                            System.out.println("thread2 is working");
                        }
                        System.out.println("thread2 end");
                        latch.countDown();
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread3=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.await();
                        System.out.println("thread3 start");
                        System.out.println("thread3 end");
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
            try {
                thread1.start();
                thread2.start();
                thread3.start();
            }
            catch (Exception ex)
            {
                System.out.println(ex.toString());
            }
    }

    运行结果如下:

    thread1 start
    thread2 start
    thread1 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    这个方法和方法二思路一样,增加一个标记量,通过判断标记量的值来确定代码是否继续执行。

    方法四:ExecutorService,代码:

    private static final ExecutorService EXECUTOR_SERVICE= Executors.newCachedThreadPool();
        public static void main(String[] args) {
    
            Thread thread1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread1 start");
                        for (int i = 0; i < 10; i++) {
                            Thread.sleep(500);
                            System.out.println("thread1 is working");
                        }
                        System.out.println("thread1 end");
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread2=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread2 start");
                        for (int i = 0; i < 5; i++) {
                            Thread.sleep(500);
                            System.out.println("thread2 is working");
                        }
                        System.out.println("thread2 end");
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread3=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        if (EXECUTOR_SERVICE.awaitTermination(10,TimeUnit.SECONDS))
                        {
                            System.out.println("thread3 start");
                            System.out.println("thread3 end");
                        }
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
            try {
                EXECUTOR_SERVICE.execute(thread1);
                EXECUTOR_SERVICE.execute(thread2);
                EXECUTOR_SERVICE.shutdown();
                thread3.start();
            }
            catch (Exception ex)
            {
                System.out.println(ex.toString());
            }
    }

    执行结果如下:

    thread1 start
    thread2 start
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    这个方法和之前的区别是它限定了等待时间,其触发逻辑是:当thread1和thread2都执行结束了,则awaitTermination返回true,如果在限定的10s内还没结束,则10s时间到时返回false。

    方法五:信号量Semaphore,代码如下:

    private static final Semaphore semaphore=new Semaphore(2);
        public static void main(String[] args) {
    
            Thread thread1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println("thread1 start");
                        for (int i = 0; i < 10; i++) {
                            Thread.sleep(500);
                            System.out.println("thread1 is working");
                        }
                        System.out.println("thread1 end");
                        semaphore.release();
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread2=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println("thread2 start");
                        for (int i = 0; i < 5; i++) {
                            Thread.sleep(500);
                            System.out.println("thread2 is working");
                        }
                        System.out.println("thread2 end");
                        semaphore.release();
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread3=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquireUninterruptibly(2);
                        System.out.println("thread3 start");
                        System.out.println("thread3 end");
                        semaphore.release();
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
            try {
                thread1.start();
                thread2.start();
                thread3.start();
            }
            catch (Exception ex) {
                System.out.println(ex.toString());
            }
    }

    执行结果如下:

    thread2 start
    thread1 start
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    这个方法的就是定义一个有两个许可证的信号量,thread3尝试去获取两个许可证,一开始它是获取不到的,因为会被thread1和thread2占用,那么它就会一直阻塞,直到这两个线程执行结束,thread3才拿到两个许可证,继续执行后面的代码。

    方法六:自定义标记量(自旋锁),代码如下:

    private static volatile int count=2;
        public static void main(String[] args) {
    
            Thread thread1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread1 start");
                        for (int i = 0; i < 10; i++) {
                            Thread.sleep(500);
                            System.out.println("thread1 is working");
                        }
                        System.out.println("thread1 end");
                        count--;
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread2=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("thread2 start");
                        for (int i = 0; i < 5; i++) {
                            Thread.sleep(500);
                            System.out.println("thread2 is working");
                        }
                        System.out.println("thread2 end");
                        count--;
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
    
            Thread thread3=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        while (count>0);
                            System.out.println("thread3 start");
                            System.out.println("thread3 end");
    
                    } catch (Exception ex) {
                        System.out.println(ex.toString());
                    }
                }
            });
            try {
                thread1.start();
                thread2.start();
                thread3.start();
            }
            catch (Exception ex) {
                System.out.println(ex.toString());
            }
    }

    执行结果如下:

    thread1 start
    thread2 start
    thread1 is working
    thread2 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread1 is working
    thread1 is working
    thread2 is working
    thread2 is working
    thread2 end
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 is working
    thread1 end
    thread3 start
    thread3 end

    这个方法实际上和方法三是一个道理,方法三的实现方案,如果你看了源码,你会发现它用了一个无限for循环。这里我们自己定义了一个标记量,如果这个标记量大于0,就一直循环等待,直到满足条件,代码继续往下执行。另外本例中的代码是有瑕疵的,count--;这步操作应该放到finally里面,这样才不会导致出现异常的时候thread3一直等待。

    7.CyclicBarrier方法:

    CyclicBarrier barrier=new CyclicBarrier(5);
    for (int i=0;i<4;i++)
    {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程"+Thread.currentThread().getId()+"开始执行");
                    Thread.sleep(2000);
                    System.out.println("线程"+Thread.currentThread().getId()+"执行结束");
                    barrier.await();
                }catch (Exception ex)
                {
                    System.out.println(ex);
                }
            }
        }).start();
    }
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                barrier.await();
                System.out.println("等待线程开始执行");
                Thread.sleep(2000);
                System.out.println("等待线程执行结束");
            }catch (Exception ex)
            {
                System.out.println(ex);
            }
    
        }
    }).start();

    CyclicBarrier的作用是等待所有的线程(按照初始化的时候给的线程数,这里是5个)都await后,再集中让所有的线程继续。

    8.Condition方法,这个和waite/notifyAll是一样的,前者本身就是后者的优化,详细信息可以看我的另一篇博客https://blog.csdn.net/dap769815768/article/details/96720712

    在这个问题上,具体的实现思路二者是完全一致的,加一个标记量,当所有的线程都云心结束了,调用Condition的signalAll方法让等待线程执行。具体的代码这里就不贴了。

    展开全文
  • 基础知识:检测线程是否结束的方法

    千次阅读 2008-08-29 18:17:00
    /** * 检测线程是否结束的方法。 * * @author 赵学庆,Java世纪网(java2000.net) * */public class ThreadDetermingFinish { public static void main(String[] args) { // 创建并启动线程 ...
  • 可是有没有人觉得在结束线程运行时候只调用shutdown方法就可以了? 实际上,只调用shutdown方法的是不够的。 我们用学校的老师和学生的关系来说明这个问题。   shutdown只是起到通知的作用 ...
  • 线程结束资源释放

    千次阅读 2016-01-13 16:28:28
    线程创建时,系统会分配给线程一些资源,我们可以看到的就是线程描述符,线程堆栈,在系统内部还会有更复杂的系统维护一些信息,在线程创建时,内核总会为其维护一些资源,比较理想的情况是线程运行结束后,释放系统...
  • 线程运行状态

    千次阅读 2018-12-05 14:10:49
    线程从创建、运行结束总是处于下面五个状态之一:新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 新建状态 当用new操作符创建一个线程时, 例如new Thread®,线程还没有开始运行,此时线程处在新建状态。 ...
  • /** * 停止线程: ... * 2.run方法结束了,当线程中没有运行的代码时,线程结束了,意味着任务结束线程消失。 * * 考虑一个问题,怎么能让run方法结束呢? * 一般情况下,run方法当中都会定义循
  • 这样就会碰到一个问题,当你开启线程,在线程没有运行完的时候,想要结束这个线程,要怎么操作呢? 标志位结束线程 这是一种我们很容易理解的结束方式。设置一个标志位,当你想要结束线程的时候,就把这个标志位的...
  • "任务结束{} taskNum = {}, costTime = {}" , Thread.currentThread () , num, costTime) ; } class TestCallable implements Callable < Integer >{ private int i ; TestCallable (int i) { ...
  • Java判断多线程是否结束

    千次阅读 2019-03-10 08:35:14
    1、确定了你开启的线程数,那么在主程序运行前。 CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。 2、在每个子线程结束后,调用 countdown.countDown(); 当...
  • 终止线程运行,最好的方法是自然返回return结束。在微软创建多线程API时,C/C++运行时库还不太成熟,导致一些API的调用与CRT会出冲突,使用CreateThread创建线程,并不是很推荐的,需要使用_beginthread。谈到线程...
  • Jmeter运行线程卡住不执行 无法结束

    千次阅读 2020-08-21 16:00:14
    问题: 在运行Jmeter的时候,出现界面请求一直无法结束,无法正常结束。 解决办法: 在http请求中添加请求响应超时时间
  • java 多线程-04-等待线程结束join()

    万次阅读 2021-06-14 10:40:37
    等待线程结束join() jdk 提供三个jion的方法 join从字面的意思就是合并的意思,也就是将几个并行线程线程合并为一个单线程执行。当一个线程必须等待另一个线程执行完毕才能执行时,可以使用join方法完成。 //调用...
  • Java停止线程运行的三种方式

    千次阅读 2017-03-14 20:26:50
    Java终止正在运行线程的方式有如下三种 1 使用退出标志,使线程正常退出,也就是run方法完成后线程终止 2 使用stop方法强行终止线程(已过时),但是不推荐使用这个方法 3 使用interrupt方法中断线程 1 使用退出...
  • 线程结束资源释放 线程终止

    千次阅读 2011-12-02 16:15:44
    线程创建时,系统会分配给线程一些资源,我们可以看到的就是线程描述符,线程堆栈,在系统内部还会有更复杂的系统维护一些信息,在线程创建时,内核总会为其维护一些资源,比较理想的情况是线程运行结束后,释放系统...
  • C++11线程学习之等待线程结束

    万次阅读 2018-03-20 11:28:42
    如果不等待线程运行结束的话,有一个问题我们需要注意:必须确保该线程结束前访问到的数据都是有效的,否则会引发异常或输出一些预料之外的结果。 实例一://-----------main.cpp #include &lt;iostream&gt...
  • main线程会比其他线程优先结束

    千次阅读 2017-08-02 13:14:29
    最近在学习volatile时,看到一篇文章关于使用volatile进行同步同步控制利用线程实现计数器,代码如下: public class Main{ private static int count = 0; public static void plus() { try { Thread.sleep...
  • 1.正常结束执行; 2.发生异常; 3.被其他线程stop(Java官方不建议) 参考:https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html 为什么Thread.stop弃用? 因为...
  • 查看线程运行状态

    千次阅读 2017-06-28 19:25:15
    线程共有6中状态:新建,运行(可运行),阻塞,等待,计时等待和终止。当使用new操作符创建新线程时,线程处于“新建”状态。当调用start()方法时,线程处于运行(可运行)状态。当线程需要获得对象的内置锁,而...
  • java线程池——接收线程运行后返回的结果 ...Executor提供了管理线程结束的方法,通过Future接口,能够跟踪一个或者多个异步线程运行的结果。 ExecutorService能够被shutdown,shutdown后,拒绝提交新的任务。Execut
  • 判断@Async注解下所有线程是否结束

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

    千次阅读 2014-10-09 15:56:39
    在看《Cplusplus Concurrency in Action Practical Multithreading》。记录一下学习过程,这是第二章等待线程结束部分
  • 1、范例演示线程运行的开始和结束 1.1 thread:标准库里的类 1.2 join() 1.3 detach() 1.4 joinable() 2.其他创建线程的方法 2.1 用类对象(可调用对象),以及一个问题范例 2.2 用lambda表达式 1、范例演示...
  • 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 ...
  • 线程---java判断多线程结束

    万次阅读 2016-10-25 16:00:36
    需求应用场景方法一isTerminatedshutdownvoid ...抛出:SecurityException - 如果安全管理器存在并且关闭,此 ExecutorService 可能操作某些不允许调用者修改的线程(因为它没有保持RuntimePermission("modifyThread
  • 异步委托开启线程,三种方法检测结束
  • int main() { HANDLE hThread=CreateThread(NULL,0,fun,NULL,...上述代码在main函数中创建一个子线程线程创建是没有问题的,但是线程却没有运行。 解决方案: 线程创建后添加如下代码 WaitForSingleObject(hThrea...
  • 我们在超级列表框里增加一个对辅助进度环节的监控反馈,它同时监控几个窗口,同时录制了线程结束的部分。 监控反馈及线程结束源码: .版本 2 .支持库 iext .支持库 EThread .子程序 监控反馈, , , 反馈线程执行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 523,107
精华内容 209,242
关键字:

如何检测线程运行结束