1、前言
程序员经常听到“并发锁”这个名词，而且实际项目中也确实避免不了要加锁。那么什么是锁？锁的是什么？今天文章从8个有意思的案例，彻底弄清这两个问题。
2、代码一：单实例synchronized调用
eat()：普通synchronized方法
sleep()：普通synchronized方法
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog = new Dog();
new Thread(() -> dog.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog.sleep()).start();
}
}
class Dog {
public synchronized void eat(){
TimeUnit.SECONDS.sleep(2);
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
普通方法加了synchronized，而synchronized锁的是该方法的调用者，也就是dog实例。这时候两个线程都由同一个dog实例调用，因此sleep()方法需要等待。
这里的eat()方法为什么也睡了2s，原因是为了排除程序打印”先吃饭“是因为方法被先调用的干扰。
3、代码二、多实例synchronized调用
eat()：普通synchronized方法
sleep()：普通synchronized方法
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog1 = new Dog();
Dog dog2 = new Dog();
new Thread(() -> dog1.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog2.sleep()).start();
}
}
class Dog {
public synchronized void eat(){
TimeUnit.SECONDS.sleep(2);
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
普通方法加了synchronized，而synchronized锁的是该方法的调用者，也就是dog实例。这时候两个线程由不同的两个实例dog1、dog2调用，因此相互之间锁不会等待，而eat()睡了2s，因此就先输出了“先睡觉”。
4、代码三、单实例synchronized和普通方法
eat()：普通synchronized方法
sleep()：普通synchronized方法
这里增加一个普通方法drink()。
思考问题：控制台先打印什么？先吃饭？还是先喝水？
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog = new Dog();
new Thread(() -> dog.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog.drink()).start();
}
}
class Dog {
public synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
public void drink(){
System.out.println("先喝水");
}
}执行结果：
原因：
drink()方法是普通方法，没有加锁，因此不会收到锁影响。
5、代码四、多实例synchronized和普通方法
eat()：普通synchronized方法
sleep()：普通synchronized方法
这里增加一个普通方法drink()。
思考问题：控制台先打印什么？先吃饭？还是先喝水？
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog1 = new Dog();
Dog dog2 = new Dog();
new Thread(() -> dog1.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog2.drink()).start();
}
}
class Dog {
public synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
public void drink(){
System.out.println("先喝水");
}
}执行结果：
原因：
drink()方法是普通方法，没有加锁，因此不会收到锁影响。
6、代码五、单实例static和synchronized调用
eat()：静态synchronized方法
sleep()：静态synchronized方法
这里eat()和sleep()添加static修饰。
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog = new Dog();
new Thread(() -> dog.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog.sleep()).start();
}
}
class Dog {
public static synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public static synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
这里加了static之后，synchronized锁的就不再是调用者实例了。由于static特性，这里锁定的是整个class类，而不是实例。
7、代码六、多实例static和synchronized调用
eat()：静态synchronized方法
sleep()：静态synchronized方法
这里eat()和sleep()添加static修饰。
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog1 = new Dog();
Dog dog2 = new Dog();
new Thread(() -> dog1.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog2.sleep()).start();
}
}
class Dog {
public static synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public static synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
这里加了static之后，synchronized锁的就不再是调用者实例了。由于static特性，这里锁定的是整个class类，而不是实例。因此这里跟多实例调用无关。
8、代码七、单实例static同步方法和普通方法调用
eat()：静态synchronized方法
sleep()：普通synchronized方法
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog = new Dog();
new Thread(() -> dog.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog.sleep()).start();
}
}
class Dog {
public static synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
eat()这里加了static之后，synchronized锁的是整个class类，而sleep()锁的是调用者实例dog；因此锁互不影响。
9、代码八、多实例static同步方法和普通方法调用
eat()：静态synchronized方法
sleep()：普通synchronized方法
思考问题：控制台先打印什么？先吃饭？还是先睡觉？
/**
* @author Shamee loop
* @date 2023/4/9
*/
public class LockDemo {
public static void main(String[] args) throws InterruptedException {
Dog dog1 = new Dog();
Dog dog2 = new Dog();
new Thread(() -> dog1.eat()).start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> dog2.sleep()).start();
}
}
class Dog {
public static synchronized void eat(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("先吃饭");
}
public synchronized void sleep(){
System.out.println("先睡觉");
}
}执行结果：
原因：
eat()这里加了static之后，synchronized锁的是整个class类，而sleep()锁的是调用者实例dog；因此锁互不影响。
10、结论
因此，对于锁。我们需要搞懂锁是谁持有的，通常一般属于调用者持有。调用者又分两类：实例调用（new），类调用（static）。这里用最简单的代码来理解锁。当然锁的机制远比这里的复杂很多，这里只是入门。