(锁) 系列篇 -- "1.synchronized实现以及与cas区别"

(锁) 系列篇

1、synchronized实现

（1）synchronized实现同步的基础：Java中的每一个对象都可以作为锁。具体表现为以下3种形式：

• 对于普通同步方法，锁是当前实例对象。

public class SynchronizedTest {
    // ......
    public synchronized void test1(){
    }
}

• 对于静态同步方法，锁是当前类的Class对象。

public class SynchronizedTest { 
     // ......
    public static synchronized void test2(){
    }
}

• 对于同步方法块，锁是Synchonized括号里配置的对象。

public class SynchronizedTest {   
    // ......
    Object lock = new Object() ;
    public void test3(){
        synchronized (lock){
        }
    }
}

（2）对于SynchronizedTest.java使用javap反解析出汇编指令(open-jdk 1.8.0)：

javac SynchronizedTest.java

javap -v SynchronizedTest.class

// ..............
{
  //.......

  public synchronized void test1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 7: 0

  public static synchronized void test2();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=0, locals=0, args_size=0
         0: return
      LineNumberTable:
        line 11: 0

  public void test3();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: getfield      #3                  // Field lock:Ljava/lang/Object;
         4: dup
         5: astore_1
         6: monitorenter
         7: aload_1
         8: monitorexit
         9: goto          17
        12: astore_2
        13: aload_1
        14: monitorexit
        15: aload_2
        16: athrow
        17: return
      Exception table:
         from    to  target type
             7     9    12   any
            12    15    12   any
      LineNumberTable:
        line 15: 0
        line 17: 7
        line 18: 17
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 12
          locals = [ class com/nancy/sync/SynchronizedTest, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4
}
SourceFile: "SynchronizedTest.java"

由此看出同步方法使用ACC_SYNCHRONIZED标识进入该方法需要同步，同块代码块使用monitorenter / monitorexit来标识同步代码块保护区。虽然实现的形式不一致，实质都是使用moniter对象头Mark Word的标志位实现。

（3）synchronized特点

• 重量锁高并发场景下效率低下(早期依赖于底层的操作系统的Mutex Lock来实现，需要内核态和用户态之间转换)
• 保证线程对变量访问的可见性、排他性、原子性

   可见性：修改变量保证其他线程可见
　　排他性：同一时刻只能一个线程访问
　　原子性：对变量的操作保证原子执行，例如：i++就是经典的读改写操作

2、cas(Compare And Swap)

（1）cas实现

cas类似乐观锁,利用操作系统指令原子执行操作,一般结合自旋实现。例如AtomicInteger#getAndIncrement方法:

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 {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    private volatile int value;

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    // .....
}

public final class Unsafe {
  public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }

   /** Volatile version of {@link #getInt(Object, long)}  */
    public native int     getIntVolatile(Object o, long offset);

  /**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);
    
   // .........
}

 通过不断自旋实现原子更新操作，可想高并发场景下虽去掉了锁的概念，但过多无效空旋也会占用CPU时间。

（2）cas实现副作用：可能引发典型"A-B-A问题": 

cas执行操作时会检查该值与期望值A是否一致(即检查内存中某个地址变量的值)，如果一致则更新为C。但如果值从原来是A，变成B，又变成了A，

那么cas进行检查时不会发现它的值发生变化，而实际已经发生了变化(1A-2B-3A)，即cas的"A-B-A问题"。

解决方式即使用版本号或者时间戳，发现不一致即更新失败。例如：AtomicStampedReference引入stamp时间戳解决"A-B-A问题"：

/**
 * An {@code AtomicStampedReference} maintains an object reference
 * along with an integer "stamp", that can be updated atomically.
 *
 * <p>Implementation note: This implementation maintains stamped
 * references by creating internal objects representing "boxed"
 * [reference, integer] pairs.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <V> The type of object referred to by this reference
 */
public class AtomicStampedReference<V> {
    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    // ......
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

    // Unsafe mechanics

    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
    private static final long pairOffset =
        objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
                                  String field, Class<?> klazz) {
        try {
            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
        } catch (NoSuchFieldException e) {
            // Convert Exception to corresponding Error
            NoSuchFieldError error = new NoSuchFieldError(field);
            error.initCause(e);
            throw error;
        }
    }
}

3、synchronized和cas二者区别

• synchronized为锁机制隐含着获锁和解锁的操作。利用操作系统提供支持实现访问竞争资源的顺序性，早期JDK版本未对synchronized优化并发效率低。后期引入轻量级锁、偏向锁等概念，大大优化性能。优势在于使用简单，维护成本低。
• cas实现了lock-free的概念，不引入锁也可解决并发场景问题。如果单纯使用cas会引起多重副作用，高级并发包下配合AQS一起可提升并发效率。
• 如果单独使用，二者都偏向并发量不高或者业务简单的场景。例如：单体web应用单调计数场景。