synchronized关键字

多线程并发访问同步问题。
java中每个对象编译后的字节码中，有个头部。
头部存储着hashcode，对象垃圾回收的年龄，还有就是内部锁信息。

线程间互斥同步就是使用synchronized实现的，synchronized关键字，在编译后，会在同步块的前后，生成monitor enter和monitor exit字节码指令。关键字锁住的是对象的锁。

synchronized关键字加锁的过程是怎样？

1. java代码碰到synchronized关键字，在编译后，会在同步块的前后，生成monitor enter和monitor exit字节码指令。
2. 线程碰到monitor enter指令后，会先判断，这个对象的锁有没有被别的线程占用，如果没有，就占用锁，并在锁的计数器上+1（锁是可以被同一个线程重入的，所以不会存在自己死锁的情况）。
3. 如果发现对象的锁已经被占用，线程就阻塞等待。
4. 当拿到锁的线程执行到monitor exit时，锁的计数器-1，当对象的锁计数器为0时，表示对象的锁被释放了。别的线程可以去拿到锁，进入同步代码块了。

java的线程使用synchronized关键字同步相较于，其他的一些操作，是很重的耗性能的操作。因为在互斥等待唤醒的操作中，java线程底层是要跟操作系统内核线程去映射的。所以开发人员在使用的时候应该特别小心哈。

因为耗性能，所以也有了相应的优化的锁的概念。要根据场景去使用设置。
对象的锁有重度锁，轻量级锁，偏向锁（大概的实现思路，就跟数据库的乐观锁是一个概念）。

synchronized关键字可以作用在哪些地方，分别的作用范围是怎样？
代码块，方法，静态方法，类

1. 作用在代码块时：
   结论：synchronized代码块只会影响同一对象（因为锁的是对象）的所有synchronized代码块的同步访问，不影响不同对象的同步访问，不影响同一对象的非synchronized代码块的同步访问。
2. 作用在方法
   结论：跟作用在代码块是一样。

public class ThreadTest implements Runnable{
    private static int count = 0;
    private synchronized void increase() {
            for (int i = 0; i < 3; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " ：" + count++);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
    @Override
    public void run() {
        increase();
    }
    public static void main(String[] args) {
        //同一个对象
        ThreadTest threadTest = new ThreadTest();
        Thread t1 = new Thread(threadTest, "t1");
        Thread t2 = new Thread(threadTest, "t2");
        t1.start();
        t2.start();
    }
}

运行结果

image.png

能看出来是互斥同步的，线程2在线程1执行结束，才开始执行。

如果不同的线程作用在不同的对象上：

public static void main(String[] args) {
        //不同线程作用在不同的对象上
        Thread t1 = new Thread(new ThreadTest(), "t1");
        Thread t2 = new Thread(new ThreadTest(), "t2");
        t1.start();
        t2.start();
    }

运行结果：

image.png

能看出来，线程间是没有约束的。

然而，synchronized可以修饰方法，但它不属于方法的一部分，因此，synchronized关键字不能被继承。如果父类方法使用synchronized关键字，而子类中覆盖了该方法，则子类这个方法默认是不同步的，必须显式地加上synchronized关键字才会同步。但是，若在子类中调用父类相应的同步方法，则子类的方法也就相当于同步了。

3. 作用在静态方法上

public class ThreadTest implements Runnable{
    private static int count = 0;
    private synchronized static void increase() {
            for (int i = 0; i < 3; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " ：" + count++);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
    @Override
    public void run() {
        increase();
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadTest(), "t1");
        Thread t2 = new Thread(new ThreadTest(), "t2");
        t1.start();
        t2.start();
    }
}

两个线程作用在不同的对象上，运行结果也是互斥同步的。
结论：跟作用在方法上不同，synchronized修饰静态方法时，作用范围是整个静态方法，作用的对象是这个类的所有对象。这是因为静态方法是属于类的而不属于对象，synchronized的内部锁锁定这个类所有对象。

4. 作用在类上

public class ThreadTest implements Runnable{
    private static int count = 0;
    private void increase() {
        synchronized (ThreadTest.class) {
            for (int i = 0; i < 3; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + " ：" + count++);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Override
    public void run() {
        increase();
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadTest(), "t1");
        Thread t2 = new Thread(new ThreadTest(), "t2");
        t1.start();
        t2.start();
    }
}

结论：作用范围是synchronized后面{}内的部分，作用的对象也是这个类的所有对象（跟作用在静态方法上一样）。

tips：

只要明白synchronized关键字是通过对象的内部锁来实现同步的，再针对具体情况具体分析（静态方法、方法、类、代码块），很快便能搞明白synchronized关键字的含义和用法。

《深入理解java虚拟机》 周志明
参考文章：https://juejin.im/entry/58070aabd20309006863772c