java synchronized的初步理解

最新推荐文章于 2024-06-04 17:00:01 发布
最新推荐文章于 2024-06-04 17:00:01 发布
阅读量340 收藏 1
点赞数
分类专栏： java基础 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yizhan_zjz/article/details/78583141
版权

本博客每一个小标题下的内容独立且完整，如只是想了解某个小标题下的内容，只需前往看该小标题即可。

1. 多线程并发访问同一个对象的同一个非静态synchronized方法

完整代码：

public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 普通同步方法A
     */
    public void methodA() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodA：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

小标题已经准确表达了上面这块代码的意思，运行结果如下：

image

由执行结果可知，两个线程中其中一个线程执行完才会执行第二个线程。结论就是，多个线程并发访问同一个对象的同一个非静态synchronized方法时，先获取到锁的线程执行完毕后才会执行其它线程。也就是说synchronized(this)这种锁可以锁定一个非静态synchronized方法，只让获取了该锁的线程执行，其它线程在该线程未执行完毕之前不能执行

2. 多线程并发访问同一个对象的不同非静态synchronized方法

完整代码：

public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodB();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 普通同步方法A
     */
    public void methodA() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodA：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 普通同步方法B
     */
    public void methodB() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodB：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果如下：

image

由执行结果可知，两个线程中其中一个线程执行完才会执行第二个线程。结论是多个线程并发访问同一个对象的不同非静态synchronized方法时，先获取到锁的线程执行完毕后才会执行其它线程。也就是说，synchronized(this)这种锁锁定的范围是该对象的所有非静态synchronized方法，而不单单是获取了该锁的线程正在执行的非静态synchronized方法

3. 多线程并发访问同一个对象的不同方法，一个是非静态synchronized方法，一个是非静态非synchronized方法

完整代码：

public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodC();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 普通同步方法A
     */
    public void methodA() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodA：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 普通方法，非同步
     */
    public void methodC() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "正在执行methodC：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下：

image

由执行结果可知，两个线程并发执行，没有先后顺序。结论是多个线程并发访问同一个对象的不同方法时，一个是非静态synchronized方法，一个是非静态非synchronized方法，这两线程并发运行。也就是说，synchronized(this)这种锁锁定的是该对象的所有非静态synchronized方法，并不会锁定该对象的非静态非synchronized方法。

4. 多线程并发访问同一个对象的不同方法，一个是非静态synchronized方法，一个是静态synchronized方法
public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();
//        final TestClass testClassNext = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodE();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 普通同步方法A
     */
    public void methodA() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodA：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 静态同步方法E
     */
    public synchronized static void methodE() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "正在执行methodE：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

运行结果如下：

image

由执行结果可知，两个线程并发执行，没有先后顺序。结论是多个线程并发访问同一个对象的不同方法时，一个是非静态synchronized方法，另一个是静态synchronized方法，这两线程并发运行。也就是说，，synchronized(this)这种锁锁定的范围是这个对象所有的非静态synchronized方法，而静态synchronized锁锁定的是该类的所有对象的所有静态synchronized方法，两个锁锁的作用范围不一样，执行起来就不会相互锁定

5. 多线程并发访问同一个类不同对象的同一个非静态synchronized方法
public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();
        final TestClass testClassNext = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodA();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClassNext.methodA();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 普通同步方法A
     */
    public void methodA() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                System.out.println(Thread.currentThread().getName() + "正在执行methodA：" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果如下：

image

由执行结果可知，两个线程并发执行，没有先后顺序。结论是多个线程并发访问同一个类不同对象的同一个非静态synchronized方法时，这两线程并发运行。也就是说，synchronized(this)这种锁锁定的范围是该对象的非静态synchronized方法，而不能锁定该类的另一个实例的非静态synchronized方法。

6. 多线程并发访问同一个类的不同对象的同一个静态synchronized方法
public class myClass {

    public static void main(String[] args) {

        final TestClass testClass = new TestClass();
        final TestClass testClassNext = new TestClass();

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClass.methodD();
            }
        }, "线程1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                testClassNext.methodD();
            }
        }, "线程2");

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

class TestClass {

    /**
     * 静态同步方法D
     */
    public synchronized static void methodD() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "正在执行methodD：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下：

image

由执行结果可知，两个线程中其中一个线程执行完才会执行第二个线程。结论是多线程并发访问同一个类的不同对象的同一个静态synchronized方法时，先获取到锁的线程执行完毕之后才会执行下一个线程。也就是说，静态synchronized锁锁定的范围已经不再是单个对象的静态synchronized方法了，而是所有对象的静态synchronized方法。

上述所有情况的总结

  1. 在一个类对象范围内，非静态synchronized锁不仅锁定当前获取该锁的线程正在执行的非静态synchronized方法，还会锁定该对象的其他所有非静态synchronized方法，但不会锁定该对象的非静态非synchronized方法、静态非synchronized方法和静态synchronized方法；

  2. 非静态synchronized锁作用范围是在一个对象里，并不会干涉到其他线程调用该类的另一个对象的非静态synchronized方法，而静态synchronized锁可以影响到其它对象；

  3. 静态synchronized锁会锁定该类的所有对象的所有静态synchronized方法，但不会锁定该类的所有对象的的静态非synchronized方法、非静态synchronized方法、非静态非synchronized方法；

  4. 非静态synchronized锁锁定的是该类的一个实例对象，静态synchronized锁锁定的其实是该类的Class对象。

yizhan_zjz
关注
专栏目录
Java对于synchronized的初步认识
weixin_56738054的博客
12-01 3155
synchronized，死锁，
synchronized关键字初步理解
HotIce0
09-27 152
synchronized关键字 synchronized（同步），也就是用于进行线程同步的关键字，共三种使用情况。 一、用于修饰static方法时 此时同步使用的是：class lock ： 类锁 同步的范围包括，该类的所有的静态方法和其实例对象的所有实例对象方法。 public static synchronized void synMethod() {} 二、用于修饰对象方法时 此时同...
Java JUC初步理解
qq_30750287的博客
05-26 79
JUC主要说的是一下几个类 ReentrantLock,synchronized,CountDownLatch,CyclicBarrier,Phaser,ReadWriteLock,Semaphore,Exchanger.
synchronized的初步理解
weixin_43160917的博客
04-13 106
1.两个线程同时访问一个对象的同步方法 需要等待线程结束 2.两个线程访问的是两个对象的同步方法 同时并行执行的 3.两个线程访问的是synchronized的静态方法 共用一把锁 会一个个的执行 4.同时访问同步方法和非同步方法 同时并行执行 Synchronized所修饰的方法才被作用 其他未被修饰的不受影响 5.访问同一个对象的不同的普通同步方法 串行 实际上拿到的是同一个this的...
Java synchronized与Lock初步解读
guohao_Kwok的博客
03-27 145
3 月，跳不动了？>>> Java中有两种加锁的方式...
Java并发关键字-synchronized
Mrs_haining的博客
11-22 153
synchronized简介 在学习知识前，我们先来看一个现象： 开启了10个线程，每个线程都累加了1000000次，如果结果正确的话自然而然总数就应该是10 * 1000000 = 10000000。可就运行多次结果都不是这个数，而且每次运行结果都不一样。这是为什么了？有什么解决方案了？这就是我们今天要聊的事情。 我们已经了解了Java内存模型的一些知识，并且已经知道出现线程安全的主要来源于JMM的设计，主要集中在主内存和线程的工作内存而导致的内存可见性问题，以及重排序导致的问题，进一步知道了hap
Java多线程初步理解
weixin_43658673的博客
12-05 88
查看尚硅谷多线程例子如题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 如题 三个窗口同时卖一百张票 你好！ ...
Java多线程之synchronized
u012928365的博客
06-04 889
了解Java多线程之synchronized
Java并发编程——Synchronized锁升级机制
BUPTZhanggg的博客
11-28 1747
Synchronized锁升级流程
毕业设计论文Nodejs+Vue宠物店管理系统.docx
10-16
毕业设计论文
（自适应手机版）响应式化工工业企业模板_网站整站打包下载.zip
10-16
（自适应手机版）响应式化工工业企业模板_网站整站打包下载.zip
金蝶与C#对接操作手册.doc
10-16
金蝶EAS凭证引入 “webservice接口”说明
毕业设计论文Django+Vue应届生求职系统.docx
10-16
毕业设计论文
idea插件之Fast-Request-API-Buddy-2024.1.7.1
10-16
安装插件重启即可，可以使用所有功能，不会提示收费弹窗
包含 10 个不同奧运会项目的 1000 张标记图像数据集
最新发布
10-16
包含 10 个不同奧运会项目的 1000 张标记图像数据集 数据说明: 该数据集包含 10 个不同奧运会项目的 1000 张标记图像:田径、羽毛球、篮球、足球、手球、橄榄球、游泳、网球、水球和举重。 所有图像的分辨率相同，为 1000x562像素，来自YouTube上的奧林匹克频道，这些帧的速率为25fps。数据集经过注释平衡和均匀分布，每个类别有 100 张图像，整个数据集共有 1000 张图像。 由于视频数据的可用性，这个数据集中的图像是从 YouTube视频中收集和随机捕获的，这些视频是真实的奥运会，包括从 1996年亚特兰大奥运会到最近在里约热内卢举行的 2016 年奥运会的不同赛事。 数据集收集代表了游戏中各种场景和视角的自然动作池，并描绘了多种观看条件下的奥林匹克赛事，这些条件包括运动员的位置、相机视角和尺度的变化。
嵌入式-优质嵌入式项目之基于STM32的多功能数控电源设计-附原理图+PCB+程序-优秀毕业设计.zip
10-16
嵌入式_优质嵌入式项目之基于STM32的多功能数控电源设计_附原理图+PCB+程序_优秀毕业设计
2024中国（上海）机器视觉技术及工业应用研讨会（VisionChina2024）嘉宾演讲PPT合集
10-16
LucidVision Labs, Inc.介绍LUCID最新的短波红外和紫外相机以及先进传感技术。 Teledyne Dalsa讨论Sherlock8视觉生态平台如何使3D和AI解决方案更加活跃和强大。 皆爱科技探讨多光谱成像-棱镜技术在新质生产力多元应用中的助力。 中国大恒集团有限公司北京图像视觉技术分公司介绍非可见光成像技术与应用。 Teledyne Dalsa展示高效能接触式宽幅CIS相机及新品TDI线扫相机如何助力行业应用转型升级。 翌视科技宁波有限公司探索工业精度新纪元线激光产品在现代工业领域的多元化应用。 北京阿丘科技有限公司工业视觉进入AI-Native大时代。 Basler基于应用介绍Basler机器视觉解决方案。 深圳赛视智能科技有限公司探讨如何利用AI解决AI视觉项目的痛点。 Teledyne e2v讨论如何选择适合应用的高性能2D与3D机器视觉解决方案。 麦威德昆山视觉技术探索机器视觉
Delphi 12 控件之TMS FNC Chart v2.6.1.7.7z
10-16
TMS FNC Chart v2.6.1.7.7z
初识C语言 C语言概述 认识C语言.pdf
10-16
初识C语言 C语言概述 认识C语言.pdf
云大软件学院Java面向对象编程初步
3. **多线程**：介绍线程的创建方式（Thread类和Runnable接口），线程同步机制（synchronized关键字、wait/notify、Lock接口等）。 4. **网络编程**：讲解Socket编程，TCP和UDP通信，以及服务器端和客户端的实现。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值