Have thread in wait, but calling notifyAll() does nothing

Question

I'm trying to learn how wait() and notify() work with Threads, and I've created the following classes to test them out. However, when I call notifyAll() to restart the other thread, my program just sits there. Doesn't exit or anything. Could someone please help me figure out what is happening?
Here is my code:
//my thread class, initializes variables and contains the methods to call wait, notify and run()
public class MyRunClass extends Thread{
public boolean A;
int startNum;
     int endNum;
     public MyRunClass(int y, String name){
          super(name);
          startNum = y;
     public synchronized void passStartNum(){
          endNum = 10;
          if(startNum > 5){
               startNum = 4;
               endNum = 10;
               try{
                    System.out.println(getName() +" going into wait " );
                    wait();
               }catch(InterruptedException a){
               System.out.println("falling out of wait");
          }else{
               endNum = 5;
     public synchronized void myloop(){
          while(startNum < endNum){
               System.out.println(getName() +" startNum: " + startNum +
"end Num: " + endNum);
               try{
                    Thread.sleep(100);
               }catch(InterruptedException e){}
               startNum++;
          if(getName().equals("Thread1")){
               System.out.println("going to do notify");
               notifyAll();
     public void run(){
          passStartNum();
          myloop();
//my class with the main() and the creation of my two threads
public class AThread{
     Thread myt;
     Thread myt2;
     public AThread(){
          myt = new Thread(new MyRunClass(1, "Thread1"));
          myt2 = new Thread(new MyRunClass(6, "Thread6")) ;
     public void startTh(){
          myt2.start();
          myt.start();
     public static void main(String args[]){
          AThread at = new AThread();
          at.startTh();
//Any help would be really appreciated!! Thanks!

Answer 1

The other responses are correct, but since this threads are a complicated topic, I'll add another rewording.
You can only call wait or notify on an object when you have that Object's monitor/lock, that is when you are synchronized on that object. ie...
Object lock = new Object();
synchronized (lock) {
    lock.wait();
}When a thread calls wait, it releases the lock, which enables another thread to grab the lock - possibly to call notify on the object, which would wake up a thread waiting on that object. (notifyAll wakes up every thread that is waiting on that object) Note that the newly-woken thread(s) still won't be able to run until the thread that called notify releases the lock, since they are still in a synchronized block.
In terms of design, if you want a single thread to wait and be woken it is appropriate to call wait and notify on the thread in question. If you are running multiple threads, and are waiting to synchronize between the threads, it is often more appropriate to call wait and notify on an object shared amongst the threads.
There are a barrage of articles and lessons on the net... try a search on thread monitors or synchronization.
-Troy