W języku Java, jak ustalić, czy wątek jest uruchomiony?

Question

Jak określić, czy wątek jest uruchomiony?

Answer 1

Thread.isAlive()

Answer 2

Sprawdzenie stanu wątek wywołując Thread.isAlive.

Answer 3

Myślę, że można użyć GetState(); Może zwrócić dokładny stan wątku.

Answer 4

Można użyć tej metody:

boolean isAlive() 

Zwraca true, jeśli wątek jest nadal żywa i false jeśli wątek jest martwy. To nie jest statyczne. Potrzebujesz odniesienia do obiektu klasy Thread.

Jeszcze jedna wskazówka: Jeśli sprawdzasz, czy ma to sprawić, aby główny wątek czekał, dopóki nowy wątek nadal działa, możesz użyć metody join(). Jest bardziej przydatny.

Answer 5

Po zakończeniu wątku powiadom swoją inną nitkę. W ten sposób zawsze będziesz dokładnie wiedzieć, co się dzieje.

Answer 6

Aby być precyzyjnym,

Thread.isAlive() Zwraca true jeśli nitka została uruchomiona (mogą nie być jeszcze działa), ale nie ukończyła jeszcze metodę run.

Thread.getState() zwraca dokładny stan wątku.

Answer 7

Myśl zapisu kodu, aby wykazać się isAlive()() getstate metod, w tym przykładzie monitoruje nitki jeszcze nie zakończona (matryc).

package Threads; 

import java.util.concurrent.TimeUnit; 

public class ThreadRunning { 


    static class MyRunnable implements Runnable { 

     private void method1() { 

      for(int i=0;i<3;i++){ 
       try{ 
        TimeUnit.SECONDS.sleep(1); 
       }catch(InterruptedException ex){} 
       method2(); 
      } 
      System.out.println("Existing Method1"); 
     } 

     private void method2() { 

      for(int i=0;i<2;i++){ 
       try{ 
        TimeUnit.SECONDS.sleep(1); 
       }catch(InterruptedException ex){} 
       method3(); 
      } 
      System.out.println("Existing Method2"); 
     } 

     private void method3() { 

      for(int i=0;i<1;i++){ 
       try{ 
        TimeUnit.SECONDS.sleep(1); 
       }catch(InterruptedException ex){} 

      } 
      System.out.println("Existing Method3"); 
     } 

     public void run(){ 
      method1(); 
     } 
    } 


    public static void main(String[] args) { 

     MyRunnable runMe=new MyRunnable(); 

     Thread aThread=new Thread(runMe,"Thread A"); 

     aThread.start(); 

     monitorThread(aThread); 

    } 

    public static void monitorThread(Thread monitorMe) { 

     while(monitorMe.isAlive()) 
     { 
     try{ 
      StackTraceElement[] threadStacktrace=monitorMe.getStackTrace(); 

      System.out.println(monitorMe.getName() +" is Alive and it's state ="+monitorMe.getState()+" || Execution is in method : ("+threadStacktrace[0].getClassName()+"::"+threadStacktrace[0].getMethodName()+") @line"+threadStacktrace[0].getLineNumber()); 

       TimeUnit.MILLISECONDS.sleep(700); 
      }catch(Exception ex){} 
    /* since threadStacktrace may be empty upon reference since Thread A may be terminated after the monitorMe.getStackTrace(); call*/ 
     } 
     System.out.println(monitorMe.getName()+" is dead and its state ="+monitorMe.getState()); 
    } 


} 

Answer 8

Thread.State klasy wyliczenia i nowy getstate() API są odpytywanie stan wykonywania gwintu.

Wątek może znajdować się tylko w jednym stanie w danym momencie. Stany te są stanami maszyn wirtualnych, które nie odzwierciedlają żadnego stanu gwintów systemu operacyjnego: [NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED].

wyliczenia Thread.State rozciąga Enum realizuje Serializable, Comparable

• getstate()^jdk5 - public State getState() {...}«Zwraca stan this wątku. Ta metoda jest przeznaczona do monitorowania stanu systemu, a nie do sterowania synchronizacją.

• isAlive() - public final native boolean isAlive();«Zwraca prawda jeśli wątek, na którym jest ona nazywana jest wciąż żywa, w przeciwnym wypadku zwraca fałszywy. Wątek jest żywy, jeśli został uruchomiony i jeszcze nie umarł.

Przykładowy kod źródłowy na klas java.lang.Thread i sun.misc.VM.

package java.lang; 
public class Thread implements Runnable { 
    public final native boolean isAlive(); 

    // Java thread status value zero corresponds to state "NEW" - 'not yet started'. 
    private volatile int threadStatus = 0; 

    public enum State { 
     NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; 
    } 

    public State getState() { 
     return sun.misc.VM.toThreadState(threadStatus); 
    } 
} 

package sun.misc; 
public class VM { 
    // ... 
    public static Thread.State toThreadState(int threadStatus) { 
     if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) { 
      return Thread.State.RUNNABLE; 
     } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) { 
      return Thread.State.BLOCKED; 
     } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) { 
      return Thread.State.WAITING; 
     } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) { 
      return Thread.State.TIMED_WAITING; 
     } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) { 
      return Thread.State.TERMINATED; 
     } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) { 
      return Thread.State.NEW; 
     } else { 
      return Thread.State.RUNNABLE; 
     } 
    } 
} 

---

przykład:

public class WorkerThreadsWait { 
    public static void main(String[] args) { 
     ThreadGroup group = new ThreadGroup("ThreadGroup1"); 

     CountDownLatch latch = new CountDownLatch(1); 

     MyThread runnableTarget1 = new MyThread(latch, 5); 
     Thread thread = new Thread(group, runnableTarget1, "Thread_1"); 
     thread.start(); 

     MyThread runnableTarget2 = new MyThread(latch, 50); 
     Thread thread2 = new Thread(group, runnableTarget2, "Thread_2"); 
     thread2.start(); 
     thread2.setPriority(Thread.MIN_PRIORITY); 

     MyThread runnableTarget3 = new MyThread(latch, 50); 
     Thread thread3 = new Thread(group, runnableTarget3, "Thread_3"); 
     thread3.start(); 
     thread3.setPriority(Thread.MAX_PRIORITY); 

     System.out.println("main Tread Execution started."); 

     for (int i = 0; i < 10; i++) { 
      System.out.println("Main \t : "+i); 
      if(i == 2) { 
       latch.countDown(); //This will inform all the waiting threads to start 
       sleepThread(1); 
      } 
     } 

     try { 

      State state = thread.getState(); 
      boolean alive = thread.isAlive(); 
      System.out.format("State : %s, IsAlive: %b \n", state, alive); 

      if(alive) { 
       System.out.println(" => Thread has started. So, joining it to main thread."); 
       thread.join(); 
       System.out.println("Main Thread waits till the Joined thread's to treminate ('not-alive')."); 
       sleepThread(1); 

       group.stop(); 
      } 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
     System.out.println("Main Thread Execution completed."); 
    } 

    static void sleepThread(int sec) { 
     try { 
      Thread.sleep(1000 * sec); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

class MyThread implements Runnable { 
    CountDownLatch latch; 
    int repeatCount; 

    public MyThread(CountDownLatch latch, int repeatCount) { 
     this.latch = latch; 
     this.repeatCount = repeatCount; 
    } 
    @Override 
    public void run() { 
     try { 
      String name = Thread.currentThread().getName(); 
      System.out.println("@@@@@ Thread : "+name+" started"); 

      latch.await(); //The thread keeps waiting till it is informed. 

      System.out.println("@@@@@ Thread : "+name+" notified"); 
      for (int i = 0; i < repeatCount; i++) { 
       WorkerThreadsWait.sleepThread(1); 
       System.out.println("\t "+ name +": "+i); 
      } 
     } catch (InterruptedException e) { 
     e.printStackTrace(); 
     } 
    } 
} 

@See również

• “implements Runnable” vs. “extends Thread”
• Thread States
• Thread States Diagram
• How to start two threads at “exactly” the same time