The following is not my code, but I have to maintain it.
The two classes have been simplified to get to the point,
try-catch blocks, among other things,  are omitted.
MyStuff has a main thread run().  And clients call
addNotification() at times.
Calling the addNotification() method in a myStuff object
sometimes hangs indefinitely.
Questions:
- should the calls mySem.release()
 and mySem.acquire() be enclosed inside the synchronized blocks?
- can anyone tell me what could cause the deadlock or hanging?
Thanks a million,
ted

class semaphore
{
  private long myCount = 0;
  public semaphore() {myCount = 0;}
  public void acquire()
  {
     synchronized(this)
     {
        while(myCount == 0){ wait(); }
        myCount--;
     }
  }
  public synchronized void release()
  {
     myCount++;
     notify();
  }
}

class myStuff
{
   private LinkList myList=null;
   private semaphore mySem = null;
   public myStuff()
   {
      myList = new LinkList();
      mySem = new semaphore()
   }
   public void addNotification(xyz a)
   {
      sychronized(myList)
      {
         myList.addList(a);
      }
      mySem.release();
   }
   public void run()
   {
       while(myThreadRun)
       {
          mySem.acquire();
          xyz ref=null;
          synchronized(myList)
          {
             ref = myList.removeFirst();
          }
          ref.foo();
       }
   }