[...]

[...]

   Read the JavaDocs:
http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Thread.html#start()

   - Oliver

You are instantiating the thread objects only once and invoking the
start method on them
repeatedly in a loop. Once a thread is started same thread cannot be
started again
move the instantiation into the loop

for(int i=0; i<10; i++) {
th1 = new Thread();
th2 = new Thread();
th1.start();
th2.start();

}

Mohan Kakulavarapu
Freelance Java Developer

This seems unnecesssarily complicated if what you want is to make
sure that at any given time only one thread is executing either
method1 or method2.  The easier alternative that occurs to me (and
there may be others) is to create a single lock object and have all
the threads use it for synchronization; this guarantees that only
one thread at a time (either a Thread1 or a Thread2) can execute
the code.  Here's my modified version of your code illustrating
what I have in mind (and adding an "id" variable for each thread
so that you can tell the instances of Thread1 apart -- probably not
needed in the real code but might be helpful here):

// (most) changed code flagged with "added" or "modified":

public class ThreadTest {

  public static long interval;

  public static boolean thread = false;

  public static void main(String[] args) {

     System.out.println("starting");

     // added
     Object lockObj = new Object();

     // modified
     for (int i = 0; i < 10 ; i++) {
         Thread1 th1 = new Thread1(lockObj, i);
         Thread2 th2 = new Thread2(lockObj, i);
         th1.start();
         th2.start();
         System.out.println("i = " + i);
     }
     System.out.println("done.");

  }

  static class Thread1 extends Thread {
     // added
     private Object lockObj;
     private int id;
     public Thread1(Object lockObj, int id) {
         this.lockObj = lockObj;
         this.id = id;
     }

     public void run() {
        method1();
     }

     private void method1() {
         // modified
         System.out.println("Thread1 (" + id + ") waiting...");
         synchronized(lockObj) {
             System.out.println("Thread1 (" + id + ") running...");
             try {
                 // sleep 5 seconds
                 sleep(5000);
             } catch (InterruptedException e) {}
             System.out.println("Thread1 (" + id + ") done.");
         }

         try {
             // sleep 2 seconds
             sleep(2000);
         } catch (InterruptedException e) {}
     }
  }

  static class Thread2 extends Thread {
      // added
     private Object lockObj;
     private int id;
     public Thread2(Object lockObj, int id) {
         this.lockObj = lockObj;
         this.id = id;
     }

     public void run() {
        method2();
     }

     private synchronized void method2() {
         // modified
         System.out.println("Thread2 (" + id + ") waiting...");
         synchronized (lockObj) {
             System.out.println("Thread2 (" + id + ") running...");
             try {
                 // sleep 5 seconds
                 sleep(5000);
             } catch (InterruptedException e) {}
             System.out.println("Thread2 (" + id + ") done.");
         }
         try {
             // sleep 2 seconds
             sleep(2000);
         } catch (InterruptedException e) {}
     }

  }
}

crash.test.dummy schrieb:

Why use Threads, then?

  for (;;) {
    task1();
    task2();
  }