synchronized关键字（二）：案例分析

其他 2020-02-07 14:25:47 阅读次数: 0

前言

synchronized系列文章
synchronized关键字（一）：实现原理

学完前一篇：synchronized关键字（一）：实现原理 之后，我们对synchronized有了深入的理解，理解之后肯定就是运用了。所以本篇主要讲解synchronized关键字的几种实际应用场景，总结了一下，synchronized关键字的主要使用场景，从易到难，大致分为以下几种情况

案例

两个线程同时访问同一个对象的非静态同步方法
public class SynchronizedDemo1 implements Runnable {

    public static void main(String[] args) {
    	// 同一个对象
        SynchronizedDemo1 lock = new SynchronizedDemo1();
        Thread thread1 = new Thread(lock, "thread-1");
        Thread thread2 = new Thread(lock, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        display();
    }

    private synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

执行结果

thread-1 -> 1569765814781 -> display()
thread-1 -> 1569765816781 -> finished
thread-2 -> 1569765816781 -> display()
thread-2 -> 1569765818782 -> finished

注意输出时间，thread-1输出display()后休眠了2秒，输出finished，马上thread-2输出display()，休眠2秒后输出finished。说明两个线程同时访问同一个对象的非静态同步方法时，同步方法是串行的，即synchronized锁有效。

两个线程同时访问两个对象的非静态同步方法
public class SynchronizedDemo2 implements Runnable {

    public static void main(String[] args) {
        // 不同对象
        SynchronizedDemo2 lock1 = new SynchronizedDemo2();
        SynchronizedDemo2 lock2 = new SynchronizedDemo2();
        Thread thread1 = new Thread(lock1, "thread-1");
        Thread thread2 = new Thread(lock2, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        display();
    }

    private synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

输出结果

thread-1 -> 1569766073360 -> display()
thread-2 -> 1569766073361 -> display()
thread-1 -> 1569766075362 -> finished
thread-2 -> 1569766075362 -> finished

从输出结果可以看出，thread-1输出display()后，thread-2马上输出display()，然后各自休眠2秒，输出finished。可以说明两个线程同时访问两个对象的同步方法时，代码不是串行的，即synchronized锁无效（使用方式错误）

两个线程同时访问synchronized静态方法
public class SynchronizedDemo3 implements Runnable {

    public static void main(String[] args) {
        // 不同对象
        SynchronizedDemo3 lock1 = new SynchronizedDemo3();
        SynchronizedDemo3 lock2 = new SynchronizedDemo3();
        Thread thread1 = new Thread(lock1, "thread-1");
        Thread thread2 = new Thread(lock2, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        display();
    }
    
    // 静态方法
    private static synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

输出结果

thread-1 -> 1569766374886 -> display()
thread-1 -> 1569766376887 -> finished
thread-2 -> 1569766376888 -> display()
thread-2 -> 1569766378888 -> finished

thread-1输出display()后休眠了2秒，输出finished，马上thread-2输出display()，休眠2秒后输出finished。说明两个线程同时访问synchronized静态方法时，同步方法是串行的（即使传入两个不同的对象），即synchronized锁有效。

两个线程同时访问非静态同步方法与普通方法
public class SynchronizedDemo4 implements Runnable {

    public static void main(String[] args) {
        SynchronizedDemo4 lock1 = new SynchronizedDemo4();
        SynchronizedDemo4 lock2 = new SynchronizedDemo4();
        Thread thread1 = new Thread(lock1, "thread-1");
        Thread thread2 = new Thread(lock2, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        if (Objects.equals(Thread.currentThread().getName(), "thread-1")) {
            // thread-1访问非静态同步方法
            display();
        } else {
            // thread-2访问普通方法
            show();
        }
    }

    // 非静态同步方法
    private synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }

    // 普通方法
    private void show() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> show()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

输出结果

thread-1 -> 1569766853881 -> display()
thread-2 -> 1569766853882 -> show()
thread-1 -> 1569766855883 -> finished
thread-2 -> 1569766855883 -> finished

thread-1输出非静态同步方法display()后，thread-2马上输出了普通方法中的show()，然后各自休眠2秒后输出finished。说明两个线程同时访问非静态同步方法与普通方法时，非静态同步方法与普通方法不是串行的，即synchronized锁无效

两个线程同时访问同一个对象的不同非静态synchronized方法
public class SynchronizedDemo5 implements Runnable {

    public static void main(String[] args) {
        // 同一个对象
        SynchronizedDemo5 lock = new SynchronizedDemo5();
        Thread thread1 = new Thread(lock, "thread-1");
        Thread thread2 = new Thread(lock, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        if (Objects.equals(Thread.currentThread().getName(), "thread-1")) {
            // thread-1访问非静态同步方法
            display();
        } else {
            // thread-2访问非静态同步方法
            show();
        }
    }

    // 非静态同步方法
    private synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }

    // 非静态同步方法
    private synchronized void show() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> show()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

输出结果

thread-1 -> 1569767264895 -> display()
thread-1 -> 1569767266896 -> finished
thread-2 -> 1569767266896 -> show()
thread-2 -> 1569767268897 -> finished

thread-1输出display()后休眠了2秒，输出finished，马上thread-2输出show()，休眠2秒后输出finished。说明两个线程同时访问同一个对象的不同非静态synchronized方法，同步方法是串行的，即synchronized锁有效。

两个线程同时访问静态synchronized方法和非静态synchronized方法
public class SynchronizedDemo6 implements Runnable {

    public static void main(String[] args) {
        SynchronizedDemo6 lock = new SynchronizedDemo6();
        Thread thread1 = new Thread(lock, "thread-1");
        Thread thread2 = new Thread(lock, "thread-2");

        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        if (Objects.equals(Thread.currentThread().getName(), "thread-1")) {
            // thread-1访问非静态同步方法
            display();
        } else {
            // thread-2访问静态同步方法
            show();
        }
    }

    // 非静态同步方法
    private synchronized void display() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> display()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }

    // 静态同步方法
    private static synchronized void show() {
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> show()");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " -> " + System.currentTimeMillis() + " -> finished");
    }
}

输出结果

thread-1 -> 1569767538794 -> display()
thread-2 -> 1569767538795 -> show()
thread-1 -> 1569767540796 -> finished
thread-2 -> 1569767540796 -> finished

thread-1输出非静态同步方法display()后，thread-2马上输出了静态同步方法中的show()，然后各自休眠2秒后输出finished。说明两个线程同时访问静态synchronized方法和非静态synchronized方法时，非静态同步方法与普通方法不是串行的，即synchronized锁无效

总结

以上几种情况，虽说看起来比较复杂，也比较绕。但是归根结底，只需要明确两点，就可以做到百战不殆。

  • 明确线程获取的是对象锁还是类锁
  • 同一把锁，在同一时刻最多被一个线程获取

上面六个案例，围绕这两点分析，相信会很好理解。

Sicimike
发布了52 篇原创文章 · 获赞 107 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/Baisitao_/article/details/101719545
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022