deadlock??

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();
        }
    }