精华内容
下载资源
问答
  • 2020-11-22 19:56:23

    提问者: 旺旺商城| 浏览次数:1904次

    class ReadFileThread implements Runnable

    {

    int i=0;

    public ReadFileThread(int i){

    this.i=i;

    }

    public void readFileThread(int i){

    try{

    //.....read file(i);

    }

    catch(Exception e){

    e.printStackTrace();

    }

    }

    public void run(){

    try

    {

    this.readFileThread(i);

    }

    catch(Exception e)

    {

    }

    }

    }

    public class TextThread

    {

    public static void main(String[] args){

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

    new Thread(new ReadFileThread(i)).start();

    }

    }

    }

    以上程序使十个进程开始读10个文件,一个进程读一个文件,现在有一个问题就是如何判断十个进程都已经结束。要用Stop人为结束吗?还是进程执行完了自动结束。最主要的还是判断十个进程是否都已结束

    问题补充:

    但是执行完了我用isAlive属性来判断,进程还是处于Runable

    满意回答

    在class ReadFileThread implements Runnable

    {

    设置一个静态变量count

    public static int count=0;

    每次建立一个线程的时候count++

    public static void main(String[] args){

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

    ReadFileThread.count++;

    new Thread(new ReadFileThread(i)).start();

    }

    然后线程结束的时候这样增加一个

    finally

    try{

    //.....read file(i);

    }

    catch(Exception e){

    e.printStackTrace();

    } finalliy{ //增加这个finally

    synchronized (this) {

    this.count--;

    }

    }

    }

    在main函数中当

    while(true)

    {

    if(ReadFileThread.count==0)//所有线程结束

    {

    //这边执行你的逻辑代码

    }

    }

    更多相关内容
  • 易语言判断多线程是否运行结束源码,判断多线程是否运行结束,子程序1
  • 易语言源码易语言判断多线程是否运行结束源码.rar
  • 方法1:thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。t.join(); //调用join方法,等待...

    方法1:thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。

    比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。

    t.join();      //调用join方法,等待线程t执行完毕

    t.join(1000);  //等待 t 线程,等待时间是1000毫秒。

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 public class TestJoin implementsRunnable {2

    3

    4 public static void main(String[] sure) throwsInterruptedException {5 Thread t = new Thread(newTestJoin());6 long start =System.currentTimeMillis();7 t.start();8 t.join(1000);//等待线程t 1000毫秒

    9 System.out.println(System.currentTimeMillis()-start);//打印出时间间隔

    10 System.out.println("Main finished");//打印主线程结束

    11 }12

    13 @Override14 public voidrun() {15 //synchronized (currentThread()) {

    16 for (int i = 1; i <= 5; i++) {17 try{18 sleep(1000);//睡眠5秒,循环是为了方便输出信息

    19 } catch(InterruptedException e) {20 e.printStackTrace();21 }22 System.out.println("睡眠" +i);23 }24 System.out.println("TestJoin finished");//t线程结束

    25 }26 //}

    27 }

    View Code

    方法2:通过同步类CountDownLatch判断当前线程的线程组中活动线程的数目,为0时其他线程运行完毕。

    同步辅助类:

    CountDownLatch是一个同步辅助类,在jdk5中引入,它允许一个或多个线程等待其他线程操作完成之后才执行。

    实现原理 :

    CountDownLatch是通过计数器的方式来实现,计数器的初始值为线程的数量。每当一个线程完成了自己的任务之后,就会对计数器减1,当计数器的值为0时,表示所有线程完成了任务,此时等待在闭锁上的线程才继续执行,从而达到等待其他线程完成任务之后才继续执行的目的。

    CountDownLatch实践

    司机和工人,工人必须等到司机来了才能装货上车,司机必须得等到所有工人把货物装上车了之后才能把车开走。

    同步类代码:

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.util.concurrent.CountDownLatch;2

    3 public class Worker implementsRunnable {4

    5 privateString workerCode;6

    7 privateCountDownLatch startLatch;8 privateCountDownLatch latch;9

    10 Worker(CountDownLatch startLatch, CountDownLatch latch, String workerCode) {11 this.startLatch =startLatch;12 this.latch =latch;13 this.workerCode =workerCode;14 }15

    16 public voidrun() {17 try{18 startLatch.await();19 doWork();20 latch.countDown();21 } catch(InterruptedException e) {22 e.printStackTrace();23 }24 }25

    26 private voiddoWork() {27 System.out.println("Worker " + workerCode + " is loading goods...");28 }29 }

    工人类

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.util.concurrent.CountDownLatch;2 importjava.util.concurrent.ExecutorService;3 importjava.util.concurrent.Executors;4

    5 public classDriver {6 public static void main(String[] args) throwsInterruptedException {7 CountDownLatch startLatch = new CountDownLatch(1);8 CountDownLatch latch = new CountDownLatch(10);9 ExecutorService executor = Executors.newFixedThreadPool(10);10

    11 for(int i=0; i<10; i++) {12 executor.execute(new Worker(startLatch, latch, "worker" +i));13 }14

    15 System.out.println("Driver is here.");16

    17 startLatch.countDown();18

    19 System.out.println("Workers get to work.");20

    21 latch.await();22

    23 System.out.println("Driver is ready to go.");24

    25 executor.shutdown();26 }27 }

    司机类

    方法3:通过java.util.concurrent.Executors中的方法创建一个线程池,用这个线程池来启动线程。启动所有要启动的线程后,执行线程池的shutdown()方法,即在所有线程执行完毕后关闭线程池。然后通过线程池的isTerminated()方法,判断线程池是否已经关闭。线程池成功关闭,就意味着所有线程已经运行完毕了。

    线程池方法示例代码:

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    1 importjava.util.concurrent.ExecutorService;2 importjava.util.concurrent.Executors;3

    4 public classTest {5

    6 public static void main(String args[]) throwsInterruptedException {7 ExecutorService exe = Executors.newFixedThreadPool(50);8 for (int i = 1; i <= 5; i++) {9 exe.execute(newSubThread(i));10 }11 exe.shutdown();12 while (true) {13 if(exe.isTerminated()) {14 System.out.println("结束了!");15 break;16 }17 Thread.sleep(200);18 }19 }20 }

    View Code

    一个思路:

    给所有的线程加上同步(同一个锁),主线程在启动其他所有线程后wait()。每个线程运行结束后,执行notify()方法。设定一个值为其他线程数量的int计数器count,写一个while循环,循环条件为count-->0,循环内容为wait()。则所有线程运行结束后正好while循环结束。

    致命缺陷:如果几个线程同时运行结束,有可能在主线程还没运行时,已经执行了好几次notify()方法。如果这样的话,while循环就永远不会结束了,主线程一直wait()下去。

    展开全文
  • Python多线程以及判断线程是否结束

    千次阅读 2022-04-27 11:39:19
    python,多线程结束

    定义多线程类

    # -*- coding: UTF-8 -*-
    """
    @项目名称:CommonFunction.py
    @作   者:陆地起飞全靠浪
    @创建日期:2022-04-11-13:40
    """
    import threading
    class MyThread(threading.Thread):
        def __init__(self, func, args):
            super(MyThread, self).__init__()
            self.func = func
            self.args = args
            self.result = None
    
        def run(self):
            self.result = self.func(*self.args)
    
        def get_result(self):
            try:
                return self.result
            except Exception:
                return None
    
        def get_enumerate(self):
            # 返回线程池中正在运行的线程数量,当结果为1时,线程全部结束
            # while True:用于判断线程是否全部结束
            #     print(threading.enumerate())
            #     if len(threading.enumerate()) == 1:
            #         return
            #     time.sleep(1)
            return threading.enumerate()
    

    功能函数及测试

    # 你的功能函数
    def test_print(a,b):
        print(a,b)
    # 测试函数
    for i in range(10):
        a,b=i,i*i
        thread1 = MyThread(test_print, args=([a,b]))
        thread1.start()
    # 等待线程全部结束
    while True:  
        if len(thread1.get_enumerate()) == 1:
            break
        print('当前运行线程:', len(thread1.get_enumerate()))
        time.sleep(1)
    
    展开全文
  • 易语言判断多线程运行结束源码
  • 主要介绍了判断Threading.start新线程是否执行完毕的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完 public class ImportThread extends Thread { private CountDownLatch threadsSignal; public ImportThread...

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


    public class ImportThread extends Thread {  
    private CountDownLatch threadsSignal;  
    public ImportThread(CountDownLatch threadsSignal) {  
    this.threadsSignal = threadsSignal;  
    }  
    @Override  
    public void run() {  
    System.out.println(Thread.currentThread().getName() + "开始...");  
    //Do somethings  
    threadsSignal.countDown();//线程结束时计数器减1  
    System.out.println(Thread.currentThread().getName() + "结束. 还有" + threadsSignal.getCount() + " 个线程");  
    }  
    }


    CountDownLatch threadSignal = new CountDownLatch(threadNum);//初始化countDown  
    for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程  
    final Iterator<String> itt = it.get(ii);  
    Thread t = new ImportThread(itt,sql,threadSignal);  
    t.start();  
    }  
    threadSignal.await();//等待所有子线程执行完  
    System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记 


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


      executor.shutdown();//只是不能再提交新任务,等待执行的任务不受影响  
      
            try {  
                boolean loop = true;  
                do {    //等待所有任务完成  
                    loop = !executor.awaitTermination(2, TimeUnit.SECONDS);  //阻塞,直到线程池里所有任务结束
                } while(loop);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  


    //
    或者
    exe.shutdown();  
            System.out.println("shutdown():启动一次顺序关闭,执行以前提交的任务,但不接受新任务。");  
            while(true){  
                if(exe.isTerminated()){  
                    System.out.println("所有的子线程都结束了!");  
                    break;  
                }  
                Thread.sleep(1000);    
            }  

    展开全文
  • 1.join()如果是一个线程,可以使用此方法,个不合适2.CountDownLatch此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完public class ImportThread extends Thread...
  • 易语言判断多线程是否运行结束源码
  • //计数器减1 } } } 2.3、方案:Future & Callable Future & Callable 使线程具有返回值的功能,其中future.get() 个是阻塞方法,通过调用所有future的get()来判断线程是否全部结束。 package ...
  • Android 多线程判断线程结束最近在做多线程断点线程的时候,遇到一个问题,因为需要在多线程下载完成时候,对文件进行处理,而处理肯定是在文件下载完成时候,而下载完成时候肯定是多线程都完成时候,所以怎么判断...
  • 实现三个线程同时执行,且可以单独关闭和运行,通过进度条实现可视化演示。
  • 如何判断线程是否都结束

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

    千次阅读 2019-03-10 08:35:14
    JAVA判断多线程是否结束应用场景主要方法实现代码 应用场景 程序中需要等待多线程任务全部执行完毕后,再执行后续操作。 主要方法 使用方法 1、确定了你开启的线程数,那么在主程序运行前。 CountDownLatch ...
  • 易语言源码易语言判断多线程运行结束源码.rar
  • 掌握的起端就是学习,知识就是这样一点点的积累来的,那么今天我们一起来学习学习与程序有关的知识,如何判断线程结束。 示例 在main函数启动6个新的线程,main函数所在的线程会等待这6个线程结束,再往下执行...
  • java中如何判断一个线程是否结束

    千次阅读 2021-02-12 16:06:54
    我们可以通过调用thread.Join()方法,把要判断线程加入到当前线程中,这样可以将两个交替执行的线程合并为顺序执行的线程。如果顺利执行,则说明该线程结束。(视频教程推荐:java视频)比如在线程B中调用了线程A...
  • 主要介绍了Java判断线程池线程是否执行完毕,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Android多线程执行判断结束标志

    千次阅读 2022-02-28 13:47:54
    fun main() { val newFixedThreadPool = Executors.newFixedThreadPool(5) val start = System.currentTimeMillis() ...println("${Thread.currentThread().name}:执行结束") } newFixedThreadPool.s
  • 逻辑处理上分成了多个模块,为了提高效率,前一个模块处理完调用后一个模块操作时使用多线程 我这里遇到的情形是前面取数据后面存到mysql,发现单线程效率很低,改为取数据后开线程存到mysql 开启线程之后性能提升一...
  • 如何判断线程运行结束

    千次阅读 2021-02-28 12:40:40
    1.join()如果是一个线程,可以使用此方法,个不合适2.CountDownLatch此为并发计数器,每个线程结束后减一(countDown()),countDownLatch.await();//等待所有子线程执行完3.线程池ThreadPoolExecutor的shutdown与...
  • 多线程---java判断线程结束

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

    千次阅读 2020-06-02 09:06:06
    为了在线程结束时保证线程安全,首先采用WaitForSingleObject自然等待结束,设置了30s的等待时间,当自然结束失败时,如果等待自然线程失败,没有办法的情况下,只能强制粗暴的结束线程,同时我们对象对计数器进行...
  • 多线程的实现方式一共有三种,实现Runable接口,集成Thread类以及使用ExecutorService、Callable、Future实现有返回结果的多线程。在这里不做详细介绍。 多线程的实现 本文的多线程主要使用实现接口的方式。首先来看...
  • 一般情况下,主线程执行完毕,子线程还未执行完毕,则会强行结束线程。 想要让子线程一直执行,则要主线程一直执行。 二、自己创建子线程 步骤: 1.添加头文件thread; 2.写初始函数; 3.main函数中写代码...
  • Java多线程超时判断

    2019-03-10 08:49:15
    Java多线程超时判断应用场景主要方法实现代码 应用场景 多线程任务中,个别线程可能发生阻塞,无法正常返回,如果等待全部线程执行完毕,程序将无法正常执行结束。此时需要为多线程设置最大执行时间,超出时间的线程...
  • 判断多线程是否执行完成(afterexecute)

    千次阅读 2021-03-18 12:34:41
    本人近来需要在servlet里另起线程池,以便控制,... 本来想着用join(),但是线程池的线程引用拿不到,如果在线程池里设置成员变量,又会引起线程不安全(事实上,join()了也没用,因为线程池的线程是不会结束的,j...
  • python多线程退出

    2020-11-26 03:10:59
    pro.waitFor();导致当前线程等待,如有必要,一直要等到由该 Process 对象表示...一般是用一个线程去做处理运行,另一个线程来做管理,try {final Process pro = Runtime.getRuntime().exec("notepad.exe");new T...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 288,766
精华内容 115,506
关键字:

多线程判断线程是否都结束