一篇文章看懂java中锁原理(纯干货)

  很多人都搞不懂锁的原理，所谓的锁到底是什么东西?
  今天我们就来揭开它神秘的面纱！
 
  很多书上，视频上都说锁是一个对象，任何对象都可以当做锁，这种说法没错，
  但是晦涩难懂，今天我就用锁的原理解释一下什么到底什么是锁，what's fuck Lock？
 
  其实所谓的就是某一个线程在某个对象上(更确切的说是对象头上)加的一个标志位，
  如下的t1方法,我们都知道这个方法的锁是调用t1()方法的TestLock01的对象，即在testSynchronized01()
  就表示锁是tl1这个对象，那么所实现的原理是怎么样的呢？
 
  其实当线程A访问tl1这个对象的方法时，会在tl1这个对象的对象头上加一个标志位，表示这个方法正在有一个线程执行
  当线程B要访问tl1的t1()方法时，会先检测tl1这个对象的方法头上是不是被别的线程加了标记，如果加了标记线程B就开始等待
  等待标记消失，当线程A执行完t1()方法时，会去掉tl1上的标记，
  当tl1对象头上的标记消失时，线程B就把自己的标记加到tl1这个对象的对象头上，表示当前线程B正在执行tl1的t1()方法，其他
  线程不得入内，这就是锁的原理
 
  解读:
  网上有很多这样的说法，比如:方法t1()锁的是TestLock01的对象，
  其实这句话的意思是调用t1()方法时线程会在该对象头上添加标志位
  testSynchronized01()方法可以证明，两个线程同时访问tl1的t1()方法
  会发生阻塞，但是testSynchronized02()方法可以证明，两个线程访问两个实例的同一个
  同步方法，不会发生阻塞，也就是说，两个线程分别在两个对象头上添加标志位，所以互相不会影响
 
 
  同理staticMethod()是在TestLock01这个类对应的Class<TestLock01>对象上添加标志位
  testStaticSynchronizedMethod01()  和 testStaticSynchronizedMethod02()的运行结果是一样的

  两个线程访问的是类的阻塞方法，即在同一个对象上添加标志位，所以会发生阻塞

package com.lyzx.concurrent.day01;

import java.util.concurrent.TimeUnit;

public class TestLock01 {
    public synchronized void t1(){
        System.out.println(Thread.currentThread().getName()+"开始");
        try {
            TimeUnit.SECONDS.sleep(2);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束");
    }

    public static synchronized void staticMethod(){
        System.out.println(Thread.currentThread().getName()+"静态方法开始");
        try {
            Thread.sleep(2000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"静态方法结束");
    }

    public static void main(String[] args) {
//        testSynchronized02();
        testStaticSynchronizedMethod02();
    }

    /**
     * 开启两个线程,synchronized锁的是同一个对象，所以两个线程不能同时进入同一个方法
     */
    private static void testSynchronized01(){
        TestLock01 tl1 = new TestLock01();

        Runnable t1 = ()->{tl1.t1();};
        Runnable t2 = ()->{tl1.t1();};

        new Thread(t1).start();
        new Thread(t2).start();
    }

    /**
     * 两个线程，调用两个对象的t1方法，互补干扰，
     * 没有线程互斥
     */
    private static void testSynchronized02(){
        TestLock01 tl1 = new TestLock01();
        TestLock01 tl2 = new TestLock01();
        Runnable t1 = ()->{tl1.t1();};
        Runnable t2 = ()->{tl2.t1();};

        new Thread(t1).start();
        new Thread(t2).start();
    }

    private static void  testStaticSynchronizedMethod01(){
        TestLock01 tl1 = new TestLock01();
        Runnable t1 = ()->{tl1.staticMethod();};
        Runnable t2 = ()->{tl1.staticMethod();};
        new Thread(t1).start();
        new Thread(t2).start();
    }

    private static void  testStaticSynchronizedMethod02(){
        TestLock01 tl1 = new TestLock01();
        TestLock01 tl2 = new TestLock01();
        Runnable t1 = ()->{tl1.staticMethod();};
        Runnable t2 = ()->{tl2.staticMethod();};

        new Thread(t1).start();
        new Thread(t2).start();
    }
}