Notify ser ikke ud til at blive kaldt

Jeg har en metode (waitGetEvent), som skal returnere når en event opstår eller efter et bestemt stykke tid (waitTime)
Til det brug anvender jeg wait(waitTime) og notify.
Min wait timer pænt ud når tiden er gået, men wait afbrydes aldrig af notify, selv om der kommer en event før tiden udløber.

Det ser nærmest ud som om metoderne blokerer for hinanden.

package dk.sysint.tlink.clientmonitor;
import org.apache.log4j.*;
import dk.sysint.tlink.callmanagergw.SoftPhone;
import java.util.Hashtable;
import java.util.ArrayList;
import java.util.Enumeration;

public class Connection extends Thread implements ConnectionObserver {
  private int Handle;
  private SoftPhone sp;
  private Hashtable monitors;
  private ConnectionState state;
  private ArrayList events;
  private Logger log = Logger.getLogger(Connection.class);
  Object lock = new Object();

  public Connection() {
    Handle = this.hashCode();
    events = new ArrayList ();
    monitors = new Hashtable();
    setState(new ConnectionIDLEFactoryFunctor());
  }
  private  synchronized void setState(ConnectionStateFactoryFunctor factory)
  {
      ConnectionStateWrapper.setFactory(factory);
      state = ConnectionStateWrapper.instance();
  }
  /**
  * Returns the handle for the connection.
  *
  * @return Handle
  * @see Connection#getHandle
  */
  public int getHandle()
  {
    return Handle;
  }
  /**
  * Returns the a Monitor object for the DN
  *
  * @return Monitor
  * @see Connection#getMonitor
  */
  public Monitor getMonitor(String DN)
  {
    return (Monitor)monitors.get(DN);
  }
  /**
  * Execute an 'Open' request.
  * to get a Connection to the PBX.
  * @return Result parameter
  * @see Connection#open
  */
  public int open() throws MethodNotAvailableInStateException
  {
    int res;
    try {
      sp = new SoftPhone();
      sp.addObserver(this);
      res = state.open(sp);
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      // Den aktive instance er ikke OK, sørg for at en ny trækkes næste gang
      ConnectionStateWrapper.setInstance(null);
      setState(new ConnectionIDLEFactoryFunctor());
      res = state.open(sp);
    }
    if (res == 0)
      setState(new ConnectionCONNECTEDFactoryFunctor());
    else
      setState(new ConnectionDISCONNECTEDFactoryFunctor());
    return res;
  }
  public int open(String ip,String user, String pw) throws MethodNotAvailableInStateException
  {
    int res;
    try {
      sp = new SoftPhone();
      sp.addObserver(this);
      res = state.open(sp, ip, user, pw);
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      // Den aktive instance er ikke OK, sørg for at en ny trækkes næste gang
      ConnectionStateWrapper.setInstance(null);
      setState(new ConnectionIDLEFactoryFunctor());
      res = state.open(sp, ip, user, pw);
    }
    if (res == 0)
      setState(new ConnectionCONNECTEDFactoryFunctor());
    else
      setState(new ConnectionDISCONNECTEDFactoryFunctor());
    return res;
  }
  /**
  * Execute an 'Close' request.
  * to get a Connection to the PBX.
  * @return Result parameter
  * @see Connection#close
  */
  public int close() throws MethodNotAvailableInStateException
  {
    try
    {
      if ( state.close(sp) == 0)
        return  cleanUp();
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      return 9999;
    }
  }
  private int cleanUp()
  {
    Monitor mon;
    try
    {
      Enumeration enum = monitors.elements();
      while(enum.hasMoreElements())
      {
        mon = (Monitor)enum.nextElement();
        removeMonitor(mon.getDN());
      }
      setState(new ConnectionDISCONNECTEDFactoryFunctor());
      return 0;
    }
    catch (Exception e)
    {
      log.error("CleanUp: ", e);
      return 9999;
    }
  }
  /**
  * Returns the state for connection
  *
  * @return Monitor
  * @see Connection#getState
  */
  public String getState()
  {
    return state.getState();
  }
  /**
  * Adds a Monitor object to the connection
  *
  * @return int
  * @see Connection#addMonitor
  */
  public int addMonitor(String DN) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = new Monitor(DN,this);
    try {
      res = state.addMonitor(sp,mon);
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      // Den aktive instance er ikke OK, sørg for at en ny trækkes næste gang
      ConnectionStateWrapper.setInstance(null);
      setState(new ConnectionIDLEFactoryFunctor());
      res = state.addMonitor(sp,mon);
    }
    if (res == 0)
    {
      sp.addMonitorObserver(mon);
      sp.getCMConnection(DN).addObserver(mon);
      monitors.put(DN,mon);
    }
    return res;
  }
  /**
  * Removes the Monitor object from the connection
  *
  * @return int
  * @see Connection#removeMonitor
  */
  public int removeMonitor(String DN) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try
    {
      mon.stopMonitor();
      res = state.removeMonitor(sp,mon);

    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      // Den aktive instance er ikke OK, sørg for at en ny trækkes næste gang
      ConnectionStateWrapper.setInstance(null);
      setState(new ConnectionIDLEFactoryFunctor());
      res = state.removeMonitor(sp,mon);
    }
    if (res == 0)
    {
      sp.removeMonitorObserver(mon);
      if (monitors.containsKey(DN))
        monitors.remove(DN);
    }
    return res;
  }
  /**
  * Make a call on the monitor for the DN
  *
  * @return int
  * @see Connection#Makecall
  */
  public int makeCall(String DN, String calledNo) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try {
      if (mon.makeCall())
      {
        mon.addCall(state.makeCall(sp,mon, calledNo));
        return 0;
      }
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("makeCall: ", e);
      return 9999;
    }
  }
  /**
  * Hang up a call on the monitor for the DN
  *
  * @return int
  * @see Connection#Hangup
  */
  public int hangup(String DN, String refid) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try {
      if (mon.hangup(refid))
      {
        return state.hangup(sp,mon, refid);
      }
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("hangup: ", e);
      return 9999;
    }
  }
  /**
  * Answer incoming call on the DN
  * @return int
  * @see Connection#Answer
  */
  public int answer(String DN) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try {
      if (mon.answer())
      {
        return state.answer(sp,mon);
      }
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("answer: ", e);
      return 9999;
    }
  }
  /**
  * Retreive call with refid on the DN
  * @return int
  * @see Connection#retreive
  */
  public int retreive(String DN, String refId) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try {
      if (mon.retreive(refId))
      {
        return state.retreive(sp,mon, refId);
      }
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("retreive: ", e);
      return 9999;
    }
  }
  /**
  * Making a consultation with another DN while having an held call on the other
  * @return int
  * @see Connection#consultation
  */
  public String[] consultation(String DN,String consultNo) throws MethodNotAvailableInStateException
  {
    int res;
    String oldRefId;
    String newRefId;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return null;
    }
    try {
      oldRefId = mon.consultation();
      if (oldRefId != null)
      {
        newRefId = mon.addCall(state.consultation(sp,mon, consultNo));
        return new String [] {oldRefId,newRefId};
      }
      return null;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("consult: ", e);
      return null;
    }
  }
  /**
  * Transferring call on the DN to another DN
  * @return int
  * @see Connection#transfer
  */
  public int transfer(String DN,String heldRefId, String newRefId) throws MethodNotAvailableInStateException
  {
    int res;
    Monitor mon = (Monitor)monitors.get(DN);
    if (mon == null)
    {
      log.error("Monitor:  " + DN + " not found");
      return 9999;
    }
    try {
      if (mon.transfer())
      {
        state.transfer(sp,mon, heldRefId,newRefId);
        return 0;
      }
      return 9999;
    }
    catch (MethodNotAvailableInStateException ex)
    {
      throw ex;
    }
    catch (Exception e)
    {
      log.error("transfer: ", e);
      return 9999;
    }
  }
  public void ConnectionChangedEvent(ConnectionEv event)
  {
    try
    {
      switch (event.getCode())
      {
        case 0:
          close();
          setState(new ConnectionDISCONNECTEDFactoryFunctor());
          System.out.println("STARTERROR");
          break;
        case 1:
          if (state instanceof ConnectionCONNECTED)
            break;
          else
            setState(new ConnectionCONNECTEDFactoryFunctor());
          System.out.println("STARTUP");
          break;
        case 2:
          cleanUp();
          setState(new ConnectionDISCONNECTEDFactoryFunctor());
          System.out.println("STOP");
          break;
        case 17:
          close();
          setState(new ConnectionDISCONNECTEDFactoryFunctor());
          System.out.println("FATALERROR");
          break;
      }
      events.add(event);
      synchronized(lock)
      {
        log.debug("i notify delen");
        lock.notify();
      }
    }
    catch (Exception e)
    {
    events.add(new ConnectionEv(17,"FATALERROR"));
    log.error("Error in connectioneventchanged: " + e.toString());
    }
  }
  public ConnectionEv getEvent()
  {
    try
    {
      if (events.size ()== 0) return null;
      ConnectionEv event = (ConnectionEv)events.get(0);
      events.remove(0);
      return event;
    }
    catch (Exception e)
    {
      log.error("Error in getevent: "+ e.toString());
      return null;
    }
  }
  public ConnectionEv waitGetEvent(int waitTime)
  {
      try
      {
        ConnectionEv ev = getEvent();
        if (ev != null)
          return ev;
          GetEventThread  waitThread = new GetEventThread(waitTime);
          waitThread.run();
/*
          try
          {
            synchronized(lock)
            {
              lock.wait(waitTime);
              log.debug("Interrupted by time");
            }
          }
          catch (InterruptedException ex)
          {
          log.debug("Interrupted by event");
          return null;
          }

*/
        return getEvent();
      }
      catch (Exception e)
      {
        return new ConnectionEv(9999, new String(e.toString()));
      }
  }
  public void run()
  {
  }
  public void shutDown()
  {
  }
  protected void setEvent(ConnectionEv event)
  {
    events.add(event);
  }
  public static void main(String[] args) {
    Connection connection1 = new Connection();
    ConnectionEv event;
    try
    {
      connection1.open();
      System.out.println("Connected OK");
      connection1.addMonitor("260");
    }
    catch (Exception e)
    {
      System.out.println("Error in open: " + e.toString());
    }
  }
  class GetEventThread extends Thread {
    int _waitTime;
    GetEventThread (int waitTime)
    {
      _waitTime = waitTime;
    }
    public void run()
    {
      try
        {
          synchronized(lock)
          {
            lock.wait(_waitTime);
            log.debug("Interrupted by time");
          }
        }
        catch (InterruptedException e)
        {
          log.debug("Interrupted by notify");
        }
    }
  }
}
nogen forslag til hvad der er galt ?