0

スレッドを生成するメイン クラスがあります。それらを 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 インスタンスがまだ生きているかどうかをチェックする while 条件を実装する方法がわからないことです。時間の長さ。MainClass には main メソッドがあります。

4

3 に答える 3

3

インスタンスを保持し、メソッドが終了する直前にThread呼び出すことをお勧めします。threadInstance.interrupt()main(...)

何かのようなもの：

 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);

ここを参照してください:クラスのコンストラクターで Thread.start() を使用すべきではないのはなぜですか?

また、 を呼び出すときにスレッドを開始していませんthreadInstance.run();。現在のスレッドで実行しているだけです。threadInstance.start()そのようなコンストラクターの内部では使用しないでください。

于 2012-10-26T19:32:45.970 に答える
1

You can use CountDownLatch which is very convenient for such tasks as waiting other threads to finish some activity (you can change Thread.sleep(...) argument in main to, say, 12000L and see what happens):

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();
    }

}
于 2012-10-26T19:46:49.600 に答える
-1 
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
              }
            }
    });
  }
}
于 2015-09-15T20:49:54.263 に答える