多线程基础学习六：synchronized的基本使用

最新推荐文章于 2023-06-16 21:47:57 发布
最新推荐文章于 2023-06-16 21:47:57 发布
阅读量231 收藏
点赞数
分类专栏： 并发学习 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010173095/article/details/78396257
版权

前面学习线程的基础知识，在此基础上学习一下关于同步的基础知识，今天就学习synchronized。

我开始找工作的时候，面试的时候经常会被人问下面的问题：

– synchronized有什么用？
– synchronized修饰不同的地方，作用有什么不同？

现在就从这两个地方开始学。

synchronized

synchronized是一个同步锁关键字，作用就是让线程只能逐一执行，不能并行执行，至于底层怎么实现，不是我这种连用都不会的人改关注的。

用法

– 修饰代码快（非静态）
测试代码（不加synchronized）：

public class Synchronized {

    public static void main (String[] args) {
        Teacher teacher = new Teacher();

        Thread first = new SynchronizedThread("first", teacher);
        Thread second = new SynchronizedThread("second", teacher);
        first.start();
        second.start();
    }

    static class SynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public SynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            teacher.say(name);
        }
    }

    static class Teacher {

        public void  say(String name) {
            System.out.println("我正在教" + name);
            //System.out.println("线程进入睡眠");
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }
    }
}

执行结果：

我正在教first
我正在教second
second睡眠三秒
first睡眠三秒

两个睡眠三秒几乎是同时出现。
测试代码（加synchronized）：

 static class Teacher {

        public void  say(String name) {
            System.out.println("我正在教" + name);
            synchronized (this) {
                //System.out.println("线程进入睡眠");
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
        }
    }

输出结果：

我正在教first
我正在教second
first睡眠三秒
second睡眠三秒

虽然看着是一样的，实际输出的时候，是先输出一个睡眠三秒，3秒之后，再输出一个睡眠三秒。

总结：在多个线程操作同一个对象，执行加锁的对象方法的时候，逐一执行同步代码块中的代码，锁的是对象实例

– 修饰对象方法

测试代码（加synchronized）：

static class Teacher {

        public synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }
    }

执行结果：

我正在教first
first睡眠三秒
我正在教second
second睡眠三秒

可以看到输出结果是先是一个线程（first）执行了方法，然后是另外一个线程（second）执行了方法。

测试代码（不加synchronized）：

static class Teacher {

        public  void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }
    }

执行结果：

我正在教first
我正在教second
second睡眠三秒
first睡眠三秒

可以看到两个线程几乎同时执行了，这和代码块的测试是一样的结果。

测试代码（一个方法不加synchronized，一个方法加synchronized）：

public class Synchronized {

    public static void main (String[] args) {
        Teacher teacher = new Teacher();

        Thread first = new SynchronizedThread("first", teacher);
        Thread second = new AnotherSynchronizedThread("second", teacher);
        first.start();
        second.start();
    }

    static class SynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public SynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            teacher.say(name);
        }
    }

    static class AnotherSynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public AnotherSynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            teacher.hello(name);
        }
    }

    static class Teacher {

        public synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }

        public void hello(String name) {
           System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }
}

执行结果：

我正在教first
我会说hello
hello second
first睡眠三秒

可以看到，多线线程执行同一个对象的同步方法和非同步方法的时候，两个方法的执行相互不影响。

测试代码（一个方法加synchronized，另外一个方法也加synchronized）：

static class Teacher {

        public synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }

        public synchronized void hello(String name) {
            System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }

执行结果：

我正在教first
first睡眠三秒
我会说hello
hello second

虽然结果不能明显看出输出顺序，但是执行时我能看到是先执行一个方法，执行完之后再执行另外一个方法。

测试代码（一个静态方法不加synchronized，一个对象方法加synchronized）：

public class Synchronized {

    public static void main (String[] args) {
        Teacher teacher = new Teacher();

        Thread first = new SynchronizedThread("first", teacher);
        Thread second = new AnotherSynchronizedThread("second", teacher);
        first.start();
        second.start();
    }

    static class SynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public SynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            teacher.say(name);
        }
    }

    static class AnotherSynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public AnotherSynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            Teacher.hello(name);
        }
    }

    static class Teacher {

        public synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }

        public static  void hello(String name) {
            System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }
}

执行结果：

我正在教first
我会说hello
hello second
first睡眠三秒

从结果上可以看到，对象方法上加同步对静态方法没有影响。

另外静态方法加上了synchronized，两个方法的执行之间也不影响。

总结：1、首先静态方法加不加同步，对实例方法没什么影响；
2、加同步的实例方法，对不加同步的实例方法没什么影响；
3、只有都是实例方法并且都加同步的情况下，才会出现同步逐一执行的效果；

静态方法

– 静态方法

上面已经知道了对象方法加同步，对静态方法没有影响。

测试代码（两个静态方法加synchronized）：

static class Teacher {


        public static synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }

        public static synchronized void hello(String name) {
            System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }

执行结果：

我正在教first
first睡眠三秒
我会说hello
hello second

可以看到，是先执行了一个方法，再执行另外一个方法。

测试代码（一个静态方法加synchronized，一个静态方法不加synchronized）：

static class Teacher {


        public static synchronized void  say(String name) {
            System.out.println("我正在教" + name);
            SleepUtil.sleep(3000);
            System.out.println(name + "睡眠三秒");
        }

        public static  void hello(String name) {
            System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }

执行结果：

我正在教first
我会说hello
hello second
first睡眠三秒

两个方法的执行没有影响。

总结：静态方法方法加同步只对加了同步的静态方法有影响。

以上都是常规的写法，实例方法给对象实例枷锁，静态方法给类枷锁。还有一些其它的写法。

其它写法

测试代码（在实例方法上加synchronized，加锁的是类）：

 static class Teacher {


        public static  void  say(String name) {
            synchronized(Teacher.class) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
        }

        public static synchronized void hello(String name) {
            System.out.println("我会说hello");
            System.out.println("hello " + name);
        }
    }

执行结果：

我正在教first
first睡眠三秒
我会说hello
hello second

执行效果，类似与两个加了同步的静态方法，这种写法是给类加锁，所有需要同步类的方法都会受影响。

测试代码（定义一个类变量（是一个对象），用来同步）：

public class Synchronized {

    private static   Test lock = new Test();

    public static void main (String[] args) {
        Teacher teacher = new Teacher();

        Thread first = new SynchronizedThread("first", teacher);
        Thread second = new AnotherSynchronizedThread("second", teacher);
        first.start();
        second.start();
    }

    static class SynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public SynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            teacher.say(name);
        }
    }

    static class AnotherSynchronizedThread  extends Thread {

        private String name;
        private Teacher teacher;

        public AnotherSynchronizedThread (String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
        }

        @Override
        public void run () {
            Teacher.hello(name);
        }
    }

    static class Teacher {


        public   void  say(String name) {
            synchronized(lock) {
                System.out.println("我正在教" + name);
                SleepUtil.sleep(3000);
                System.out.println(name + "睡眠三秒");
            }
        }

        public static  void hello(String name) {
            synchronized(lock) {
                System.out.println("我会说hello");
                System.out.println("hello " + name);
            }

        }
    }    

    static class Test   {    

    }
}

执行结果：

我正在教first
first睡眠三秒
我会说hello
hello second

这种写法等效于类加同步，或者实例加同步，不过同步的对象变为了自己定义的另外一个对象。

总结

synchronized同步：
同步实例对象时，只对使用这个对象锁的方法有影响；
同步类时，只对使用这个类锁的方法有影响；

流浪的神明吗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程基础部分.md，学习代码
06-21
在IT行业中，多线程是实现高...总结来说，多线程基础部分的学习涵盖了线程创建、线程状态、线程同步、ThreadLocal的使用以及并发编程的高级概念。通过深入理解这些内容，开发者可以编写出更加高效、稳定的多线程程序。
synchronized的四种用法
诚的博客
05-07 9138
同步锁 synchronized顾名思义，就是用来进行一些同步工作的，我们常常在多线程的环境中使用到它，实现互斥的效果。 每一个java对象都可以当做一个同步锁，线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得锁的唯一途径就是进入这个锁的保护的同步代码块或方法。这里的同步代码块和同步方法，就是使用synchronized关键字标记的代码块和方法。比如： synchronized (object) { //doSomething... .
深入学习synchronized
Lxd_的博客
07-22 116
一、Java内存模型JMM 在介绍JMM之前，先说说计算机的结构，冯诺依曼计算机结构： CPU 是计算机运算和控制的核心，我们的程序最终都会变成指令让CPU去执行 内存 程序都是在内存中运行的，内存会保存程序运行中的数据，供CPU处理 缓存 由于CPU的运算速度和内存的读写速度差距很大，导致每次CPU操作内存都要耗费很长的时间，于是在CPU和内存之间加上缓存，最靠近CPU的缓存称为L1，然后依次是L2，L3和主内存，越靠近CPU的缓存速度越快，存储容量越小。CPU缓存模型结构如下： 二、Java内
静态方法上加锁synchronized
weixin_36802143的博客
01-17 1326
关键字sychronized获得的锁都是对象锁,而不是代码块的锁. 所以代码中哪个线程先执行sychronized关键字的方法,哪个线程就持有这把锁 在静态方法上加锁synchronized 表示锁定.class类 类级别锁 public class MultiThread { private static int num = 0; /**不加static * 这样线程获得m1和m...
synchronized学习
lucyLee的博客
10-17 292
1. synchronized的三种使用方式 之前，学习集合类时，经常提到某些集合是线程同步的，或者说线程安全的 因为，它们的方法使用synchronized进行修饰，以保证实例对象是线程安全的 1.1 普通同步方法 普通同步方法：synchronized修饰普通成员方法，锁住的是当前类的实例对象 普通同步方法如下：每隔10毫秒打印0 ~ 5的数值 public synchronized void printNum() { try { for (int i = 0; i
synchronized用法详解
ganmaotong的博客
06-01 1万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
学习多线程使用这个笔记就够了
02-02
本笔记将从基础概念开始，逐步深入到高级主题，帮助你从零基础到熟练掌握Java多线程。 **1. 进程与线程** - **进程**：是程序运行的实例，是系统分配资源的基本单位，具有并发性、异步性、动态性、独立性和结构性。...
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
《Java程序设计基础》章：多线程处理(与“线程”有关文档共45张).pptx
11-14
Java程序设计基础中的多线程处理是编程领域中至关重要的一部分，尤其对于Java开发者而言。多线程允许程序同时执行多个任务，从而提高了程序的效率和响应性。在讲解这一主题时，我们首先需要理解线程的基本概念。 1....
java基本教程之多线程基本概念 java多线程教程
09-04
本文将深入探讨在JDK中新增Java.util.concurrent（JUC）包之前的Java多线程基础。 首先，我们需要理解线程的基本状态。线程在生命周期中会经历五种不同的状态： 1. 新建状态（New）：当通过`new Thread()`创建一个...
学 Synchronized 看这一篇就够了，从入门到精通
最新发布
weixin_46724181的博客
06-16 254
CAS的全称是：Cmpare And Swap(比较相同并替换)。是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。CAS操作依赖3个值：内存中的值V，旧的预估值X, 需要修改的目标值B。如果内存中的值V和旧的预估值X相等，那么就将目标值B保存在内存当中，否则什么都不做。整个比较替换的过程是个原子操作。CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量成功，其他线程都失败，失败的线程并不会被挂起，而是被告知这次竞争失败，并再次尝试。
synchronized 详解
GeGe&YoYo的博客
08-03 2127
synchronized 是什么？应该怎么使用？ synchronized底层之monitor、对象头、Mark Word synchronized的锁重入、锁消除、锁升级原理？无锁、偏向锁、轻量级锁、自旋、重量级锁，锁的升级过程 synchronized怎么保证可见性、有序性、原子性？ ...
静态方法和非静态方法上加锁的区别
小泽的博客
06-06 2354
1.静态方法加锁：类锁 Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁” 2.非非静态方法加锁:对象锁 Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁” public class TestSyn { private static int num = 20; // 单例模式 静态内部类 public stat...
java 静态方法枷锁_Java synchronized静态方法使用synchronized加锁
weixin_39925413的博客
02-24 876
昆明达内Java培训的老师上一期讲了Java synchronized实例方法使用synchronized加锁，这一期给同学们讲Java synchronized静态方法使用synchronized加锁。二、静态方法中使用synchronized加锁静态方法中默认被加锁的对象是此静态方法所在类的class对象。1 classstaticMethodSynchronized {2public...
Synchronized（对象锁）和Static Synchronized（类锁）的区别
cs408的博客
10-06 3万+
Synchronized和Static Synchronized区别 通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchroniz
Synchronized学习总结
Since Gate
03-21 180
Synchronized 学习总结 1.用法 A.synchronized 修饰普通的方法，此时锁的是当前实例的对象 B.修饰静态方法 public static synchronized methodC() {}//对类加锁，即对所有此类的对象加锁 C.synchronized修饰代码块： 锁定的是括号内的对象 public void synMethod0() { synchronized (this){ //do something } } 2.底层语义 synchronized 修饰实例方法 其本质与
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
静态方法上的锁
阿伟已经走了
07-21 403
new出来两个不同的成员变量的话，如果执行方法输出的话可能会有两个线程同时访问锁，这时候它访问的就是我的synchronized所修饰的方法，而这两个线程就拥有我方法所属对象的锁，如果是synchronized所修饰的静态方法时，这个时候就表示给.class类加锁，这个时候我的线程就独占这个锁，而不是将这个锁分给其他线程...
Java多线程基础解析：从入门到理解核心概念
"java多线程基础篇讲解" Java多线程是编程领域的重要概念，尤其在现代计算系统中，多线程模型对于充分利用系统资源、提高应用程序性能具有至关重要的作用。本文将对Java多线程的基础知识进行讲解，适合初学者入门。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值