Java锁机制

每个对象都有一把锁，锁在对象头中，关于对象的组成我们可以加入来依赖看看java对象头到底是啥样的

 <!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core -->
        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
        </dependency>

  然后进行测试

@Test
    public void testAnnotation() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Apple apple = new Apple();
        apple.setAppleName("apple");
        apple.num = 12;
        test(apple);
//        synchronized (apple) {
            System.out.println(ClassLayout.parseInstance(apple).toPrintable());
//        }

    }

打印结果如下: 

annotation.Apple object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4                    (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4                    (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4                    (object header)                           e4 2c 01 f8 (11100100 00101100 00000001 11111000) (-134140700)
     12     4                int Apple.num                                 12
     16     4   java.lang.String Apple.appleName                           (object)
     20     4   java.lang.String Apple.appleColor                          null
Instance size: 24 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

从VALUE那一栏及其对应的整数值，我们可以知道，第一行object header(java成为mark word)最低8位是左边的00000001，对应无锁状态, 锁位置如下

 如果我们把代码改成

 @Test
    public void testAnnotation() throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Apple apple = new Apple();
        apple.setAppleName("apple");
        apple.num = 12;
        test(apple);
        
        synchronized (apple) {
            System.out.println(ClassLayout.parseInstance(apple).toPrintable());
        }

    }

输出结果为:

annotation.Apple object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4                    (object header)                           38 e3 5f e9 (00111000 11100011 01011111 11101001) (-379591880)
      4     4                    (object header)                           ae 00 00 00 (10101110 00000000 00000000 00000000) (174)
      8     4                    (object header)                           21 2d 01 f8 (00100001 00101101 00000001 11111000) (-134140639)
     12     4                int Apple.num                                 12
     16     4   java.lang.String Apple.appleName                           (object)
     20     4   java.lang.String Apple.appleColor                          null

可以看到最低位为00111000，为轻量级锁，照理说synchronized默认应该是偏向锁，为什么这个就直接就是轻量级锁呢，我猜，是不是因为上面有个test，而test其实会调用线程栈的(所以可能会生成一个新的线程)，所以有两个线程争用这个锁，最后导致其升级为轻量级锁

关于synchronized关键字在字节码中是如何表示的，可看下图:

 右边字节码28行monitorenter就是对应synchronized(apple)这一行，其实49行还有monitorexit，两个monitor关键字就相当于一个括号，把代码包裹起来

锁有4种，无锁，偏向锁，轻量级锁，重量级锁(由低到高，只能升级)

先来聊聊无锁编程，也就是CAS，compareAndSwap，这个例子，假设有一个女神(资源对象)，当她状态为0的时候可以被约出去，接收约会以后，状态会变成1，此时有两个男生(线程)，都想约她出去，这个时候就会出现竞争，就是男生1和男生2都想把女神状态变成1，假设男生1先问的，女生的old value = 0，new value也为0， 因此提出约会，女生答应以后，状态new value = 1， 此时男生2不知情，去找女神，于是比较了old value = 0 和new value = 1，两者不相等，也就不能改变女神状态，但是一般这种情况，男生2不会放弃，而是会自旋(就是一个while循环，轮询女神(资源)是否可用)，不过为了避免死循环，一般会设定自旋次数，比如10次

不过值得指出的是compare和swap是两个操作，如果在男生1的compare和swap中间，男生2做了compare，因为女生状态没有改变仍为0，所以男生2也会去做swap，为了防止这种情况发生，就有赖于CPU厂商提供的原子级别的compareAndSwap操作指令，比如x86的cmpxchg指令，这就是所谓的乐观锁，其实乐观锁并没有锁机制

偏向锁

偏向锁就算是已经加锁了(通过synchronize)，锁可能会偏向某个线程，那么因为锁对象处于偏向锁状态，前23个bit是线程id，我们只要比较锁对象的线程id和当前线程id是否一致，一致则把锁给该线程，锁偏向这个线程。

偏向锁和轻量级锁的区别是:

偏向锁假定将来只有第一个申请锁的线程会使用锁（之后不会再有任何线程再来申请锁），所以只要存储一个线程id就行，类似于我们假定只有单线程场景

轻量级锁

相对来说，轻量级锁，就对应了两个线程的场景 (我自己的观点)

如果发现有多个线程竞争该锁，那么比较锁的线程id和当前线程id的结果就是false，那么此时锁会升级，升级成轻量级锁

轻量级锁，锁对象(lock record)和线程是相互指向的

其他线程也可能访问这个锁对象，在轻量级锁的情况下，如果B线程想获得这个对象，但是这个对象被A线程占有，那么B线程就会自旋等待，如果超过一个线程在自旋，那么这个时候，锁就会由轻量级锁升级为重量级锁。

重量级锁

重量级锁，其实就对应多个线程(我自己的观点)，这个时候会有超过一个线程在自旋

Java里面如何用乐观锁

参考AtomicInteger:

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;

里面的getAndIncrement方法,其调用了unsafe的getAndAddInt方法，而getAndAddInt就是用的CAS:

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

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));
         // compareAndSwapInt是本地方法

        return var5;
    }

上面的while循环，对应的就是自旋，自旋的次数就是循环的次数，默认配置为10

不过有一点比较好奇，getIntVolatile是什么，参考

https://objcoding.com/2018/11/29/cas/

悲观锁

就是 互斥锁

在java里面通过synchronized 关键字实现