线程同步(一)

Java的线程同步机制比较少,大致分两种,

一、锁对象

示例代码:

myLock.lock();//a reentrantLock object
try
{
    //critical section
}
final
{
    //make sure the lock is unlocked even if an exception is thrown
    myLock.unlock();
}

这一结构确保任何时刻只有一个线程进入临界区。一旦一个线程封锁了锁对象,其它任何线程都无法通过lock语句。当其它线程调用lock时,它们被阻塞,直到第一个线程释放锁对象。注意:

1)此锁对象是对象级的,锁的是对象实例,

2)此锁对象是可重入的,同一线程中可以lock一次,两次,甚至更多,在同一线程中,如果lock了两次,必须unlock两次,其它线程才能再次访问。

示例代码:银行转账的示例。代码生成2个账户,每个账户1000元,要求2个账户同时随机转账而不出错。

银行用Bank类表示,里面实现了转账功能和查询总账的功能,账户用accounts数组表示。

程序主要由两个工作线程完成,每个工作线程执行这样的动作:向另一个账户转账,然后打印出两个账户的总额。(假设转账是免费的)

示例代码(此代码必然造成总额出错):

/**
 * 客户测试代码,测试两个线程同时转账最终出错。
 * @author luhx
 *
 */
public class BankTransferTest 
{
    public static void main( String[] args )
    {
        System.out.println( "BankTransferTest begin!" );
        
        Bank b = new Bank();
      
        //第一个转账线程
        TransferRunnable r0 = new TransferRunnable(b, 0, 1);
        Thread t0 = new Thread(r0);
        t0.start();
        
        //第二个转账线程
        TransferRunnable r1 = new TransferRunnable(b, 1, 0);
        Thread t1 = new Thread(r1);
        t1.start();
        
        System.out.println( "BankTransferTest end!");
    }
}

 

 

/**

 * 银行类,实现转账功能和查询总账的功能
 * @author luhx
 *
 */
public class Bank {
    public int []accounts = {1000, 1000};
    
    /**
     * 转账
     * @param from
     * @param to
     * @param money
     */
    void transfermoney(int from, int to, int money)
    {
        if(accounts[from] < money)//
        return ;
        
        accounts[from] -= money;
        accounts[to] += money;
        
        System.out.println("from:" + from + "to:" + to + "money:" + money +"");
        System.out.println("totalMoney: " + getTotalMoney() + "");
 
    }
    
    /**
     * 查询总金额
     * @return
     */
    int getTotalMoney()
    {
        int sum = 0;
        for(int a : accounts)
        {
            sum += a;
        }
        return sum;
    }
}

 

 
/**
 * 线程类,将转账动作绑定到工作线程中执行
 * @author luhx
 *
 */
public class TransferRunnable implements Runnable{
    private Bank bank;
    private int from;
    private int to;
    final private int DELAY = 100;
    
    TransferRunnable(Bank bank, int from, int to)
    {
        this.bank = bank;
        this.from = from;
        this.to = to;
    }
    
    public void run()
    {
        while(true)
        {
            int toAccount = (int)(1000 * Math.random());
 
            try {
                bank.transfermoney(from, to, toAccount);
                Thread.sleep(DELAY);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

 

经过分析,我们得知,由于两个线程同时对账户1和2进行存取,必然存在冲突,因此需要同步,同步的方法很简单,只需在动到两账户的函数内加上锁即可,重新修改Bank类,然后再运行,发现总额总是2000,不再产生错误。

/**
 * 银行类,实现转账功能和查询总账的功能
 * @author luhx
 *
 */
public class Bank {
    public int []accounts = {1000, 1000};
    
    //银行锁
    private Lock bankLock;
    private Condition condition;
    
    
    Bank()
    {
        bankLock = new ReentrantLock();
        condition = bankLock.newCondition();
    }
    /**
     * 转账
     * @param from
     * @param to
     * @param money
     */
    void transfermoney(int from, int to, int money) throws InterruptedException
    {
        bankLock.lock();
        try{
            if(accounts[from] < money)//如果钱不够,则等待
                 condition.await();
            
            accounts[from] -= money;
            accounts[to] += money;
            System.out.println("from:" + from + "to:" + to + "money:" + money +"");
            System.out.println("totalMoney: " + getTotalMoney() + "");
            
            condition.signalAll();
        }
        finally
        {
            bankLock.unlock();
        }
    }
    
    /**
     * 查询总金额
     * @return
     */
    int getTotalMoney()
    {
        bankLock.lock();
        try{
            int sum = 0;
            for(int a : accounts)
            {
                sum += a;
            }
            return sum;
        }
        finally
        {
            bankLock.unlock();
        }
 
    }
}

 

使用对象锁比较麻烦,需要比较多的额外代码,可以用synchronized进行简化,使用之重改Bank类后如下所示

/**
 * 银行类,实现转账功能和查询总账的功能
 * @author luhx
 *
 */
public class Bank {
    public int []accounts = {1000, 1000};
 
    /**
     * 转账
     * @param from
     * @param to
     * @param money
     */
    public synchronized void transfermoney(int from, int to, int money) throws InterruptedException
    {
        if(accounts[from] < money)//如果钱不够,则等待
             wait();
        
        accounts[from] -= money;
        accounts[to] += money;
        System.out.println("from:" + from + "to:" + to + "money:" + money +"");
        System.out.println("totalMoney: " + getTotalMoney() + "");
        
        notifyAll();
        
    }
    
    /**
     * 查询总金额
     * @return
     */
    public synchronized int getTotalMoney()
    {
        try{
            int sum = 0;
            for(int a : accounts)
            {
                sum += a;
            }
            return sum;
        }
        finally
        {
        }
 
    }
}
posted @ 2011-12-14 15:23  绿色的麦田  阅读(186)  评论(0编辑  收藏  举报