通过模拟银行账户取钱操作，彻底了解Java多线程中的乐观锁和悲观锁！

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

下面我就通过模拟银行账户取钱的场景，在不加锁、使用悲观锁和乐观锁的不同方式下看看程序的执行结果。希望此篇文章可以帮到正在努力的你。

1. 先看一下无锁状态时程序执行的结果

package com.smallfan.atomic;

import java.util.ArrayList;
import java.util.List;

/**
* @PACKAGE_NAME: com.smallfan.atomic
* @NAME: AtomicTest
* @USER: dell
* @DATE: 2020/5/23
* @PROJECT_NAME: aboutthread
* 通过一个模拟银行取钱的demo，彻底分清乐观锁和悲观锁
*/
public class AtomicTest {
   //
   public static void main(String[] args) {
       Account.testWithdraw(new AccountSafe(10000));
   }

}

class AccountSafe implements Account {
   private Integer balance;

   public AccountSafe(Integer balance) {
       this.balance = balance;
   }

   @Override
   public Integer getBalance() {
           return balance;
   }

   @Override
   public void withdraw(Integer amount) {
           balance -= amount;
   }
}

/**
* 定义账户的接口
*/
interface Account {
   // 获取余额
   Integer getBalance();

   // 取款
   void withdraw(Integer amount);

   /**
    * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
    * 如果初始余额为 10000 那么正确的结果应当是 0
    */
   static void testWithdraw(Account account) {
       List<Thread> ts = new ArrayList<>();
       long start = System.nanoTime();
       for (int i = 0; i < 1000; i++) {
           ts.add(new Thread(() -> {
               account.withdraw(10);
           }));
       }
       ts.forEach(Thread::start);
       ts.forEach(t -> {
           try {
               t.join();//等待线程执行结束
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       });
       long end = System.nanoTime();
       System.out.println("最终结果还剩："+account.getBalance() + " cost: " + (end - start) / 1000_000 + " ms");
   }
}

执行结果：最终结果还剩：830 cost: 270 ms

3. 修改代码添加synchronized关键字，实现悲观锁

/**
代码修改部分 添加synchronized 关键字保证原子性操作
*/
@Override
   public Integer getBalance() {
       synchronized (this){
           return balance;
       }
   }
   @Override
   public void withdraw(Integer amount) {
       synchronized (this){
           balance -= amount;
       }
   }

4. 乐观锁实现方式，其实乐观锁就是无锁

/**
 * CAS操作 乐观锁
 */
class AccountSafeAsAtomic implements Account{
    AtomicInteger balance;
    public AccountSafeAsAtomic(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }
    @Override
    public Integer getBalance() {
        return balance.get();
    }
    @Override
    public void withdraw(Integer amount) {
        while (true){
            int currentValue = balance.get();//当前值
            int nextValue = currentValue - amount;//取钱后的值
	         if(balance.compareAndSet(currentValue,nextValue)){//CAS操作
                break;
            }
        }
    }
}

执行结果：最终结果还剩：0 cost: 198 ms

乐观锁和悲观锁两种实现方式结果比较：
（悲观）最终结果还剩：0 cost: 268 ms （乐观）最终结果还剩：0 cost: 198 ms
执行多次发现同样操作情况下乐观锁的效率执行更高。