java多线程中，需要防止代码块受并发访问产生的干扰。比如下图的并发访问，如果不使用锁机制，就会产生问题
可以看到这里之前线程2之前的5900被后来线程1写入的5500直接覆盖了，导致add 900 这个操作消失了。
public class Bank { private final double[] accouts; public Bank(int n,double initialBalance) { accouts = new double[n]; Arrays.fill(accouts, initialBalance); } public void transfer(int from, int to, double amount) throws InterruptedException{ if (accouts[from] < amount) return; System.out.println(Thread.currentThread()); accouts[from] -= amount; System.out.printf("%10.2f from %d to %d", amount, from, to); accouts[to] += amount; System.out.printf(" Total Balance: %10.2f%n", getTotalBalance()); } public double getTotalBalance() { double sum = 0; for (double a : accouts) sum += a; return sum; } public int size(){ return accouts.length; } } public class UnsynchBankTest { public static final int NACCOUNTS = 100; public static final double INITIAL_BALANCE = 1000; public static final double MAX_AMOUNT = 1000; public static final int DELAY = 10; public static void main(String[] args) { Bank bank = new Bank(NACCOUNTS,INITIAL_BALANCE); for (int i = 0; i < NACCOUNTS; i++) { int fromAccount = i; Runnable r = ()->{ try{ while(true){ int toAccount = (int) (bank.size() * Math.random()); double amount = MAX_AMOUNT * Math.random(); bank.transfer(fromAccount, toAccount, amount); Thread.sleep((int) (DELAY * Math.random())); } }catch (InterruptedException e){} }; Thread t = new Thread(r); t.start(); } } }
该程序由于没有加锁
所以会出现金额总数出错的情况，参考上图覆盖写入的情况。
所以我们要使用锁机制在使用临界资源时对其加锁（禁止其他线程并发访问或防止并发访问时产生干扰）
实现加锁就主要有下面几种方法：
一、使用ReentrantLock类+Condition条件对象
首先使用ReentraLock类就能实现简单的加锁了，在这种锁机制下，临界区需要使用try-finally括起来，因为加锁之后，若临界区里运行出现问题而抛出异常，也要确保锁被释放，否则其他线程会一直拿不到锁而无法运行。
单使用ReentrantLock的代码如下：
public class Bank { private final double[] accouts; private Lock banklock; public Bank(int n,double initialBalance) { accouts = new double[n]; Arrays.fill(accouts, initialBalance); banklock = new ReentrantLock(); } public void transfer(int from, int to, double amount) throws InterruptedException{ banklock.lock(); try{ System.out.println(Thread.currentThread()); accouts[from] -= amount; System.out.printf("%10.2f from %d to %d", amount, from, to); accouts[to] += amount; System.out.printf(" Total Balance: %10.2f%n", getTotalBalance()); }finally { banklock.unlock(); } }
这样加了锁之后，确实金钱总额不会再发生改变，一直是100000，但当我把账户当前剩余资金打印出来时，发现：
其实账户剩余资金为0了，竟然也还在转账！
这样显然是不可以的。那么就需要在线程进入临界区后，判断某一条件，满足之后才继续执行，否则进入阻塞状态，并释放自己持有的锁。
但这个判断又不能使用简单的if：
这样的线程完全有可能在成功通过if之后，但在transfer之前被中断，然后在线程再次运行前可能账户余额已经低于提款金额。所以就要用到条件对象了，首先创建新的Condition对象：
private Condition sufficientFunds;
如果transfer发现余额不足，就调用sufficientFunds.await();
此时当前进程就会被阻塞，并放弃锁。此时我们希望另一个线程拿到锁可以进行增加自己余额的操作。
进入阻塞状态的线程，即使锁可以，他也不能马上解除阻塞，直到另一个线程调用同一个条件上的signalAll方法为止。
所以另一个线程转账完毕后，应该调用sufficientFunds.signalAll();这一调用会重新激活因为这一条件而被阻塞的所有线程，这些线程会从等待集中被移出，再次成为可运行的，这时他应该再去检测该条件——因为signalAll方法仅仅是通知正在等待的线程：此时有可能已经满足条件，值得再次去检测该条件。
所以检测条件的语句应该这么写：
while(!(ok to proceed)) condition.await();
对bank改造如下：
public class Bank { private final double[] accouts; private Lock banklock; private Condition sufficientFunds; public Bank(int n,double initialBalance) { accouts = new double[n]; Arrays.fill(accouts, initialBalance); banklock = new ReentrantLock(); sufficientFunds = banklock.newCondition(); } public void transfer(int from, int to, double amount) throws InterruptedException{ banklock.lock(); try{ while (accouts[from] < amount) sufficientFunds.await(); System.out.println(Thread.currentThread()); accouts[from] -= amount; System.out.printf("%10.2f from %d to %d, remain %10.2f", amount, from, to,accouts[from]); accouts[to] += amount; System.out.printf(" Total Balance: %10.2f%n", getTotalBalance()); sufficientFunds.signalAll(); }finally { banklock.unlock(); } } public double getTotalBalance() { banklock.lock(); try { double sum = 0; for (double a : accouts) sum += a; return sum; }finally { banklock.unlock(); } }
加上了锁和条件对象，运行后得到如图结果：
可以看到余额不会再出现负数的情况。