【JUC基础】03. 几段代码看懂synchronized

精选原创

有一只柴犬 2023-06-03 00:21:15 博主文章分类：java ©著作权

文章标签 java c++ 算法 System 多实例 文章分类 Redis 数据库

©著作权归作者所有：来自51CTO博客作者有一只柴犬的原创作品，请联系作者获取转载授权，否则将追究法律责任

1、前言

2、什么是synchronized

3、代码一：单实例synchronized调用

4、代码二、多实例synchronized调用

5、代码三、单实例synchronized和普通方法

6、代码四、多实例synchronized和普通方法

7、代码五、单实例static和synchronized调用

8、代码六、多实例static和synchronized调用

9、代码七、单实例static同步方法和普通方法调用

10、代码八、多实例static同步方法和普通方法调用

11、结论

1、前言

程序员经常听到“并发锁”这个名词，而且实际项目中也确实避免不了要加锁。那么什么是锁？锁的是什么？今天文章从8个有意思的案例，彻底弄清这两个问题。

2、什么是synchronized

Java中的一个保留字（关键字）。加了synchronized表明该段代码为同步块，也称之为同步锁。synchronized的作用是保证在同一时刻，被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。JDK1.5之前synchronized是一个重量级锁，相对于JUC中的Lock，它会显得那么笨重，随着Javs SE 1.6对synchronized进行的各种优化后，synchronized并不会显得那么重了。简单的使用示例代码为：

public synchronized void doSomething(){
    ...   
}

或

public void doSomething() {
    synchronized(this){
        ...    
    }
}

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 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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_算法

原因：

普通方法加了synchronized，而synchronized锁的是该方法的调用者，也就是dog实例。这时候两个线程都由同一个dog实例调用，因此sleep()方法需要等待。

这里的eat()方法为什么也睡了2s，原因是为了排除程序打印”先吃饭“是因为方法被先调用的干扰。

4、代码二、多实例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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_多实例_02

原因：

普通方法加了synchronized，而synchronized锁的是该方法的调用者，也就是dog实例。这时候两个线程由不同的两个实例dog1、dog2调用，因此相互之间锁不会等待，而eat()睡了2s，因此就先输出了“先睡觉”。

5、代码三、单实例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("先喝水");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_System_03

原因：

drink()方法是普通方法，没有加锁，因此不会收到锁影响。

6、代码四、多实例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("先喝水");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_java_04

原因：

drink()方法是普通方法，没有加锁，因此不会收到锁影响。

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 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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_java_05

原因：

这里加了static之后，synchronized锁的就不再是调用者实例了。由于static特性，这里锁定的是整个class类，而不是实例。

8、代码六、多实例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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_c++_06

原因：

这里加了static之后，synchronized锁的就不再是调用者实例了。由于static特性，这里锁定的是整个class类，而不是实例。因此这里跟多实例调用无关。

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 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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_多实例_07

原因：

eat()这里加了static之后，synchronized锁的是整个class类，而sleep()锁的是调用者实例dog；因此锁互不影响。

10、代码八、多实例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("先睡觉");
    }
}

执行结果：

【JUC基础】03. 几段代码看懂synchronized_多实例_08

原因：

eat()这里加了static之后，synchronized锁的是整个class类，而sleep()锁的是调用者实例dog；因此锁互不影响。

11、结论

因此，对于锁。我们需要搞懂锁是谁持有的，通常一般属于调用者持有。调用者又分两类：实例调用（new），类调用（static）。这里用最简单的代码来理解锁。当然锁的机制远比这里的复杂很多，这里只是入门。

上一篇：【JUC基础】11. 并发下的集合类

下一篇：【JUC基础】07. wait()，notify()虚假唤醒

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯