使用 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
