Having a problem with threads and using locks

Question

I was hoping someone could give me some hits on getting my code to run properly. The problem I am having is I think my locks and unlocks are not working properly. Plus, for some reason I always get the same output, which is:
Withdrawal Threads         Deposit Threads            Balance
Thread 2 attempts $29 Withdrawal - Blocked - Insufficient Funds
Thread 4 attempts $45 Withdrawal - Blocked - Insufficient Funds
Thread 6 attempts $34 Withdrawal - Blocked - Insufficient Funds
Thread 7 attempts $40 Withdrawal - Blocked - Insufficient Funds
                                Thread 1 deposits $187          $187
                                Thread 3 deposits $169          $356
                                Thread 5 deposits $61           $417
Press any key to continue...If someone can see the error I made and doesn't mind explaining it to me, so I can learn from it, I would appreciate that very much.
/************Assign2_Main.java************/
import java.util.concurrent.*;
public class Assign2_Main
{//start Assign2_Main
    public static void main(String[] args)
    {//start main
           // create ExecutorService to manage threads
           ExecutorService threadExecutor = Executors.newCachedThreadPool();
        Account account = new SynchronizedThreads();
        Deposit deposit1 = new Deposit(account, "Thread 1");
        Deposit deposit2 = new Deposit(account, "Thread 3");
        Deposit deposit3 = new Deposit(account, "Thread 5");
        Withdrawal withdrawal1 = new Withdrawal(account, "Thread 2");
        Withdrawal withdrawal2 = new Withdrawal(account, "Thread 4");
        Withdrawal withdrawal3 = new Withdrawal(account, "Thread 6");
        Withdrawal withdrawal4 = new Withdrawal(account, "Thread 7");
        System.out.println("Withdrawal Threads\t\tDeposit Threads\t\t\tBalance");
        System.out.println("------------------\t\t---------------\t\t\t-------\n");
        try
            threadExecutor.execute(withdrawal1);       
            threadExecutor.execute(deposit1);     
            threadExecutor.execute(withdrawal2);  
            threadExecutor.execute(deposit2);    
            threadExecutor.execute(withdrawal3);
            threadExecutor.execute(deposit3);       
            threadExecutor.execute(withdrawal4);
        catch ( Exception e )
             e.printStackTrace();
            //shutdown worker threads
           threadExecutor.shutdown();
    }//end main
}//end Assign2_Main/******************Withdrawal.java****************************/
public class Withdrawal implements Runnable
{//start  class Withdrawal
      *constructor
    public Withdrawal(Account money, String n)
         account = money;
         name = n;
    public void run()
    {//start ruin
         int newNum = 0;
            newNum = account.getBalance(name); 
           Thread.yield();
    }//end run
    private Account account;
    private String name;
}//end  class Withdrawal/*******************Deposit.java***************/
import java.util.Random;
public class Deposit implements Runnable
{//start class Deposit
      *constructor
    public Deposit(Account money, String n)
         account = money;
         name = n;
    public void run()
    {//start run
            try
                 Thread.sleep(100);
               account.setBalance(random.nextInt(200), name);
            }// end try
            catch (InterruptedException e)
              e.printStackTrace();
   }//end run
   private Account account;
   private Random random = new Random();
   private String name;
}//end class Deposit/********************Account.java*****************/
*Account interface specifies methods called by Producer and Consumer.
public interface Account
     //place sum into Account
     public void setBalance(int sum, String name);
     //return  value of Account
        public int getBalance(String name);         
} /**************SynchronizedThreads.java****************/
import java.util.concurrent.locks.*;
import java.util.Random;
public class SynchronizedThreads implements Account
{//start SynchronizedThreads
      *place money into buffer
    public void setBalance(int amount, String name)
    {//start setBalance
         // lock object
         myLock.lock();           
        sum += amount;
        System.out.println("\t\t\t\t" + name + " deposits $" + amount +"\t\t$"+ sum+"\n");       
           //threads are singnaled to wakeup
        MakeWD.signalAll();
          // unlock object                                                
        myLock.unlock();
       }//end setBalance
        *gets the balance from buffer
       public int getBalance(String name)
    {//start getBalance
         int NewSum = random.nextInt(50);
         //lock object
        myLock.lock();
        try
             if(sum > NewSum)
                 //takes NewSum away from the account
                 sum -= NewSum;
                    System.out.println(name + " withdraws $" + NewSum +"\t\t\t\t\t\t$"+ sum+"\n");
            else
                 System.out.println(name +  " attempts $" + NewSum + " Withdrawal - Blocked - Insufficient Funds\n");                 
                 //not enough funds so thread waits
                    MakeWD.await();         
            //threads are singnaled to wakeup
            MakeD.signalAll();     
            }//end try
        catch (InterruptedException e)
               e.printStackTrace();
        finally
             //unlock object
             myLock.unlock();
        return NewSum;     
     }//end getBalance
     private Random random = new Random();  
     private Lock myLock = new ReentrantLock();
     private Condition MakeD = myLock.newCondition();
     private Condition MakeWD = myLock.newCondition();
     private int sum = 0;
}//end SynchronizedThreads

Answer 1

You can also try to provide a greater Priority to your player thread so that it gains the CPU time when ever it needs it and don't harm the playback.
However a loop in a Thread and that to an infinite loop is one kind of very bad programming, 'cuz the loop eats up most of your CPU time which in turn adds up more delays of the execution of other tasks (just as in your case it is the playback). By witting codes bit efficiently and planning out the architectural execution flow of the app before start writing the code helps solve these kind of issues.
You can go through [this simple tutorial|http://oreilly.com/catalog/expjava/excerpt/index.html] about Basics of Java and Threads to know more about threads.
Regds,
SD
N.B. And yes there are more articles and tutorials available but much of them targets the Java SE / EE, but if you want to read them here is [another great one straight from SUN|http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html] .
Edited by: find_suvro@SDN on 7 Nov, 2008 12:00 PM