Java synchronized关键字

使用 Synchronized 关键字来解决并发问题是最简单的一种方式，我们只需要使用它修饰需要被并发处理的代码块、方法或字段属性，虚拟机自动为它加锁和释放锁，并将不能获得锁的线程阻塞在相应的阻塞队列上。
下面通过几个例子看下Synchronized 的用法
1、不加锁控制

public class TestSynchronized {
    
    public void print1() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }
    
    public void print2() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }

    private void sleep(int time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    

    public static void main(String[] args) {
        
        TestSynchronized obj = new TestSynchronized();
        
        Thread threadA = new Thread(new Runnable() {            
            @Override
            public void run() {
                obj.print1();
            }
        });
        
        Thread threadB = new Thread(new Runnable() {            
            @Override
            public void run() {
                obj.print2();
            }
        });
        
        threadA.start();
        threadB.start();
        
    }

}

上述代码没有通过Synchronized 控制，print1和print2方法分别在不同的线程中执行，可以想象结果应该是交叉输出的

Thread-1 : 4
Thread-0 : 4
Thread-1 : 3
Thread-0 : 3
Thread-0 : 2
Thread-1 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0

2、使用Synchronized

    public synchronized void print1() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }
    
    public synchronized void print2() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }

可以看出结果是依次打印的

Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0

print1()和print2()前面的Synchronized获取的是同一个锁，都是当前对象实例的内置锁，所以当有一个线程获取了这个锁之后，其他需要调用带Synchronized方法的线程只能阻塞。
3、Synchronized修饰代码块

    public void print1() {
        synchronized (this) {       
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                sleep(500);
            }
        }
    }
    
    public synchronized void print2() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }

结果一样是依次输出

Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0
Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0

代码块前的synchronized 和print2()前的synchronized获取的都是同一个对象的内置锁。
4、引入static

    public void print1() {
        synchronized (this) {       
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + " : " + i);
                sleep(500);
            }
        }
    }
    
    public static synchronized void print2() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
            sleep(500);
        }
    }

结果又变成交叉的了

Thread-1 : 4
Thread-0 : 4
Thread-1 : 3
Thread-0 : 3
Thread-1 : 2
Thread-0 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0

代码块前的synchronized获取的是当前对象的内置锁， print2是static获取的是类对象的内置锁，两个锁之前不存在竞争关系，同一个线程可以同时拥有两把锁。

原理解析

synchronized的使用需要借助java的内置锁，首先看下内置锁是什么
java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
示例2和3都是依次输出的，说明两个线程获取的都是同一个对象锁。
示例4 synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。
引自：
https://www.cnblogs.com/edwardru/articles/6030686.html

synchronized是可重入的
引自：
https://blog.csdn.net/u012545728/article/details/80843595

Java synchronized关键字

原理解析

推荐阅读更多精彩内容