189 8069 5689
今天就跟大家聊聊有关java中如何实现悲观锁与乐观锁，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。
创新互联是一家专注于网站建设、成都网站设计和西信服务器托管的网络公司，有着丰富的建站经验和案例。
1、 悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。在Java语言中synchronized关键字的实现就悲观锁。
2、乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS（ Conmpare And Swap 比较并交换）实现的。
从上面的描述我们可以看出2种锁其实各有优劣，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。
悲观锁其实没什么好讲，这里主要讲解写乐观锁。
JAVA的乐观锁主要采用CAS算法即 compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数
需要读写的内存值 V
进行比较的值 A
拟写入的新值 B
当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。正因为不断重试所以如果长时间不成功，会给CPU带来非常大的执行开销。
这样说或许有些抽象，我们来看一个例子：
1.在内存地址V当中，存储着值为10的变量。
2.此时线程1想要把变量的值增加1。对线程1来说，旧的预期值A=10，要修改的新值B=11。
3.在线程1要提交更新之前，另一个线程2抢先一步，把内存地址V中的变量值率先更新成了11。
4.线程1开始提交更新，首先进行A和地址V的实际值比较（Compare），发现A不等于V的实际值，提交失败。
5.线程1重新获取内存地址V的当前值，并重新计算想要修改的新值。此时对线程1来说，A=11，B=12。这个重新尝试的过程被称为自旋。
6.这一次比较幸运，没有其他线程改变地址V的值。线程1进行Compare，发现A和地址V的实际值是相等的。
7.线程1进行SWAP，把地址V的值替换为B，也就是12。
在JAVA中是通过Unsafe类提供的一系列compareAndSawp*方法来实现
首先我们先研究下Unsafe，初始化Unsafe用到Unsafe.getUnsafe() ;
通过查看源码我们发现这个类我们不能直接使用
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
//判断调用类是否BootstrapClassLoader加载,Unsafe是系统Jar包按JAVA双亲委派模式，这个类是由BootstrapClassLoader加载的。而普通项目的类是由CustomClassLoader加载
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}我们继续看源码发现有3个CAS操作方法
var1: 要修改的对象
var2: 对象中field的偏移量
var4: 期望值（预期的原值）
var5: 更新值
返回值 true/false
这里可以看到这几个方法都是native方法，低层都是调操作系统的方法，这里不深入研究
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5); public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
因为Unsafe不方便调用（当然我们可以通过反射勉强也可以用），所以我们只能拿AtomicInteger来研究下。我们new AtomicInteger()时，会获取AtomicInteger对像Value字段的偏移量
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
// 通过Unsafe方法获取value字段的偏移量(可以理解为C++的指针）
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
...
}我们再来看下atomicInteger.getAndIncrement()这个方法的实现
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}它最终调用的是unsafe的getAndAddInt方法，我们继续往下跟踪
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}由上图可知，var1是AtomicInteger对象，var2是AtomicInteger对象value字段的偏移量，var5是期望值expected，var5+var4=var5+1。这么说可能比较清楚点，例如：
AtomicInteger atomicInteger = new AtomicInteger(2); int a = atomicInteger.getAndIncrement() ;
则var5为2，var5+var4=2+1=3。我们从上上图可以看出，这里用了个循环也就是说当期望值不是2时会一直循环尝试。相等就把x值赋值给offset位置的值,不相等，就取消赋值，方法返回false。这也是CAS的思想，及比较并交换。用于保证并发时的无锁并发的安全性。
这里有同学可能会担心死循环问题，其实不会的大家可以看下AtomicInteger那个类是设置成volatile类型，也就是内存可见所有线程获取到的值都是最新的。但是用循环却会产生ABA的问题。 即如果在此之间，V被修改了两次，但是最终值还是修改成了旧值V，这个时候，就不好判断这个共享变量是否已经被修改过。
为了防止这种不当写入导致的不确定问题，原子操作类提供了一个带有时间戳的原子操作类。带有时间戳的原子操作类AtomicStampedReference CAS（V，E，N）当带有时间戳的原子操作类AtomicStampedReference对应的数值被修改时，除了更新数据本身外，还必须要更新时间戳。当AtomicStampedReference设置对象值时，对象值以及时间戳都必须满足期望值，写入才会成功。因此，即使对象值被反复读写，写回原值，只要时间戳发生变化，就能防止不恰当的写入。
以下是AtomicStampedReference类的compareAndSet方法
/** * Params: expectedReference – 当前值 newReference – 修改后的值 expectedStamp – 当前时间戳 newStamp – 修改后的时间戳 return true/false * */ public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)
以下是我的测试例子
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASTest {
public static void main(String[] args) {
int initialStamp = 1;
AtomicStampedReference atomicStringReference = new AtomicStampedReference( "value1", initialStamp);
boolean exchanged1 = atomicStringReference.compareAndSet("value1", "value2", initialStamp, initialStamp+1);
System.out.println("exchanged: "> 看完上述内容，你们对java中如何实现悲观锁与乐观锁有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。