线程依赖关系Java

Question

我有一个产生线程的主类，让我们称它们为MainClass和MyThread。

public class MainClass extends javax.swing.JFrame { 
    int sharedVariable; 
    MyThread threadInstance; 
    public MainClass(){ 
     sharedVariable = 2; 
     threadInstance = new MyThread(this); 
     threadInstance.run(); 
    } 

    public int getSharedVariable(){ return sharedVariable; } 

    public static void main(String[] args){ 
    //begin main class 
} 
} 


public class MyThread implements Runnable { 

    MainClass class; 
    public MyThread(MainClass main_class){ 
     this.main_class= main_class; 
     } 

    @Override 
    public run(){ 

    while(this.main_class is still active){ 

     //grab status of sharedVariable and wait for x amount of time. 
     } 
    } 
    } 

的问题是我不知道如何实现它检查是否MainClass实例仍然活着，而条件，如果是，它必须使用this.main_class.getSharedVariable（）来获取值共享变量，然后等待x时间。 MainClass有主要方法。

Answer 1

我会建议在main(...)方法退出之前保持Thread实例，然后调用threadInstance.interrupt()。

喜欢的东西：

public static void main(String[] args){ 
    MainClass mainClass = new MainClass(); 
    try { 
     ... 
     // do main stuff here 
     ... 
    } finally { 
     mainClass.threadInstance.interrupt(); 
    } 
} 

然后在你的线程你会做：

while(!Thread.currentThread().isInterrupted()){ 
    ... 
} 

也会希望正确处理InterruptedException：

try { 
    Thread.sleep(1000); 
} catch (InterruptedException e) { 
    // always a good pattern to re-interrupt the thread here 
    Thread.currentThread().interrupt(); 
    // if we are interrupted quit 
    return; 
} 

顺便说一句，它是非常不良形式泄漏实例到另一个线程施工期间的对象：

new MyThread(this); 

在这里看到：Why shouldn't I use Thread.start() in the constructor of my class?

而且，当你调用threadInstance.run();你是不是启动一个线程。你只是在当前线程中运行它。你应该使用threadInstance.start()而不是像这样的构造函数。

Answer 2

您可以使用CountDownLatch这是此类任务非常方便，因为等待其他线程来完成一些活动（您可以在主，比方说，12000L改变Thread.sleep(...)参数，看看会发生什么）：

import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.TimeUnit; 

class OtherThread extends Thread { 
    private final CountDownLatch sharedLatch; 

    OtherThread(CountDownLatch sharedLatch) { 
     this.sharedLatch = sharedLatch; 
    } 

    @Override 
    public void run() { 
     boolean wokenByMain = false; 
     try { 
      wokenByMain = sharedLatch.await(10000L, TimeUnit.MILLISECONDS); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
      return; // or not return, whatever makes more sense in your case 
     } 
     System.out.println("heh: " + wokenByMain); 
    } 
} 
class SOSample { 

    public static void main(String[] args) throws InterruptedException { 
     CountDownLatch latch = new CountDownLatch(1); 
     OtherThread otherThread = new OtherThread(latch); 
     otherThread.start(); 
     System.out.println("Scheduled other thread to be started"); 
     Thread.sleep(1000L); 
     System.out.println("going to release other thread"); 
     latch.countDown(); 
    } 

} 

Answer 3

public class MainClass extends JFrame implements Runnable { 
    public static void main(String [] args) { 
    final Thread t=new Thread(new MainClass() { 
      public void run(){ 
       //something 
      }); 
    Thread t2=new Thread(new MyThread() { 
      public void run() { 
       while(t.isAlive) { 
       //something 
       } 
      } 
    }); 
    } 
}