[JUC-02] Synchronized

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量125 收藏
点赞数
分类专栏： 并发编程 文章标签： java 并发编程 synchronized 虚假唤醒
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29051413/article/details/107817379
版权

文章目录

1、Synchronized

  在 Java 中，每个对象有且仅有一把锁（lock），也称为监视器（monitor）。

  synchronized 是 Java 中的关键字，是一种同步锁。它修饰的目标有以下几种：
  1、修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象（锁）是调用这个代码块的对象；
  2、修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
  3、修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
  4、修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用的对象是这个类的所有对象。

  在并发编程中存在线程安全问题，主要原因有：
  1.存在共享数据
  2.多线程共同操作共享数据。

  关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2、Synchronized的使用

  使用并发编程的原则是：线程操作资源类。

2.1 修饰代码块

public class Demo01 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "A").start();
        
        new Thread(() -> {
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "B").start();
        
        new Thread(() -> {
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "C").start();
    }
}

class Ticket {
    private int number = 30;

    public void sale() {
        synchronized (this) {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出 "+this.toString()+" 的第 " + (30 - (number--) + 1) + " 张票，还剩余 " + number + " 张票。");
            }
        }
    }
}

  运行结果：
在这里插入图片描述
  分析：资源类为Ticket，三个线程分别是 A、B、C，this就是ticket对象。
  1、三个线程启动后，三个线程都可以操作ticket对象；
  2、当三个线程都进入了sale()方法，遇到了同步代码块，此时，哪个线程手快先拿到ticket对象的锁，谁就进入，其他两个就在此等待，因为一个对象只有一个锁；
  3、当执行完同步代码块，就把锁释放了，即此时ticket对象又有锁了。

  结果就是，同一时间，只有拿到锁的线程才能访问同步代码块，其他没拿到锁的只能处于阻塞状态等待。这是只有一个对象的情况，如果有ticket2对象，那么，操作这个ticket2对象的线程和操作ticket对象的线程没有什么关系。

2.2 修饰非静态方法

public class Demo02 {
    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "A").start();

        new Thread(() -> {
            Ticket ticketB = new Ticket();
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "B").start();

        new Thread(() -> {
            Ticket ticketC = new Ticket();
            for (int i = 0; i < 40; i++) ticket.sale();
        }, "C").start();
    }
}

class Ticket {
    private int number = 30;

    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出 "+this.toString()+" 的第 " + (30 - (number--) + 1) + " 张票，还剩余 " + number + " 张票。");
        }
    }
}

  运行结果：
在这里插入图片描述
  分析：和修饰代码块的分析一样，此时的锁也是从this对象获取。

2.3 修饰静态方法

public class Demo03 {
    public static void main(String[] args) {

        new Thread(() -> {
            for (int i = 0; i < 40; i++) new Ticket().sale();
        }, "A").start();

        new Thread(() -> {
            Ticket ticketB = new Ticket();
            for (int i = 0; i < 40; i++) new Ticket().sale();
        }, "B").start();

        new Thread(() -> {
            Ticket ticketC = new Ticket();
            for (int i = 0; i < 40; i++) new Ticket().sale();
        }, "C").start();
    }
}

class Ticket {
    private static int number = 30;

    public static synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第 " + (30 - (number--) + 1) + " 张票，还剩余 " + number + " 张票。");
        }
    }
}

  运行结果：
在这里插入图片描述
  分析：A、B、C 三个线程操作的是三个对象，根据结果可知，此时的锁已经不是Ticket对象了，因为synchronized修饰的是静态方法，此时的锁是Ticket类的所有对象，即所有对象共用一把锁。

3、生产者消费者问题

3.1 一个生产者和一个消费者

  所谓生产者消费者问题，指的是一个线程负责生产数据，一个线程负责消费数据。消费者消费的数据必须是来源于生产者生产的数据，要做到这一点就得进行线程同步操作。

  下面举一个例子，一个资源类有一个number变量，初始值为 0，资源类有两个方法，分别是 increment() 和 decrement() 分别对number进行加一、减一操作。

  下面是一个资源类：

class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number != 0) { //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

  测试：

public class ProdAndCons {
    public static void main(String[] args) {

        Data data = new Data();
        
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
    }
}

  运行结果如下：
在这里插入图片描述
  运行很正常。
  1、生产者A判断出number为0，则进行加一操作，然后执行notifyAll()方法告知消费者B来消费。如果生产者A判断出number不为0，说明消费者B还没消费，则生产者A进入 WAITING 状态，直到被唤醒。

  2、消费者B判断出number不为 0，则进行减一操作，然后执行notifyAll()方法告知生产者A继续生产。如果消费者B判断出number为0，说明生产者A还没生成，则消费者B进入 WAITING 状态，直到被唤醒。

3.2 多个生产者和多个消费者

  现在多增加一个生产者和一个消费者：

public class ProdAndCons {
    public static void main(String[] args) {

        Data data = new Data();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}

  运行效果：
在这里插入图片描述
  可以发现一个诡异的现象：出现了非1非0的数字。

3.3 虚假唤醒

  原因诊断：出现这些2、3、4的原因就是多个生产者线程进入increment()方法，这些线程进入的时候，number为0，然后这些线程都给number进行了加一操作。

  更加诡异：加一方法和减一方法都是用了 synchronized 关键字修饰了的，怎么可能出现多个线程同时进去的情况？

  这个现象在 Java 官方称为“虚假唤醒”，究其原因就出现在wait()方法上：
在这里插入图片描述
  官方的意思说：只要把wait()的触发判断改为循环，就可以避免，我们来尝试一下：

class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) { //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

  把 if 改成了 while，运行结果如下：
在这里插入图片描述
  还真的是正常了，这又是什么原理？？

3.4 虚假唤醒的本质

  问题就出在wait()方法上，我们看这个方法的官方文档：
在这里插入图片描述
  文档说的很晦涩，一句一句翻译一下：

  当前的线程必须拥有该对象的显示器：显示器其实来源于单词（monitor），其实就是锁的意思，即：要调用wait()方法，当前线程必须拥有调用wait()方法的对象的锁；

  该线程释放此监视器的所有权：调用了wait()方法后，锁也给扔了；

  并等待另一个线程通知等待该对象监视器的线程通过调用notify方法或notifyAll方法notifyAll：等着被其他线程唤醒。

  看明白了这三句话，就知道虚假唤醒问题出在哪了，就在这关键的一句话：该线程释放此监视器的所有权。也就是说，锁扔了。那锁扔了会有什么后果呢？后果就是阻塞中的、等待获取这个锁的线程直接就拿到锁了，然后进入 synchronized 方法了。

  要知道，上面的代码中，wait()方法是在 synchronized 修饰的方法里面，还没出去。这就导致多个线程同时进入了 synchronized 修饰的方法里面。

  我们引入 synchronized 来修饰方法，就是为了避免多个线程对变量的一个状态同时进行判断，比如：number 为 0，然后多个线程在同一时刻判断它，结果多个线程都认为该加一，导致的后果就是每个线程都给它加一，最终效果就不是加一了，而是执行了多次加一。

  下面仔细分析出现虚假唤醒后的逻辑：

  A、B 线程是生产者，对 number 进行加一操作。

  1、A 线程进入increment()方法，判断出 number 等于1，于是 this.wait()，丢掉了锁。

  2、线程 B 拿到了锁，进入了increment()方法，此时 number 已经被消费了，为 0，线程 B 判断出 number 为 0，于是进行了加一操作，然后线程 B 离开 synchronized 方法，释放了锁并this.notifyAll()通知所有等待中的线程；

  3、线程 A 被唤醒，同时也拿到了锁，继续往下执行了加一操作，这时，number 就变为 2了。

  我们分析出，只要线程 A 在恢复并拿到锁之后，再判断一次 number 的状态，即可避免再加一，这就是官方文档要我们使用循环的原因了。

  线程 A 在丢掉锁之后，这个 synchronized 方法已经被其他的线程 B 进入了，为了避免出错，线程 A 应对当前状态再进行判断，这是最安全的操作。

学哥斌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tuling-juc-final.zip
05-23
并发编程代码demo
JUC(二)--synchronized原理
Cloud的专栏
09-06 1599
线程状态 NEW 线程刚被创建，但还没调用start方法 RUNNABLE 调用start方法后，包含运行状态和阻塞状态(如IO操作，此时不占用CPU资源) BLOCKED,阻塞，如synchronized的时候等待别的线程释放锁 WAITING,等待，如调用join TIMED_WAITING,限时等待，如调用sleep TERMINATED,线程终止 线程安全分析 成员变量和静态变量是否线程安全? 如果没有共享，则线程安全，如果被共享了，但只是只读，则线程安全,如果有读写操作，则..
juc学习02 synchronized和synchronized实现案例
weixin_42537314的博客
08-23 93
1.synchronized是java中的关键字，是一种同步锁，他修饰的对象有以下几种 修饰一个代码块，被修饰的代码块被称为同步语句，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象 修饰一个方法，被修饰的方法称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象 虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而
JUC之synchronized的使用
qq_38167579的博客
03-08 251
在JAVA多线程里面，为了保证线程对某个资源的排队访问，通常会使用synchronized关键字来加锁保证。那么对synchronized不同的使用方式，也会产生不同的效果。现列举一些场景来理解synchronized关键字使用方式。 首先新建一个测试类 public class SynTest { // 普通方法 public void normal(String name) { ...
JUC-- synchronized锁 以及 lock锁
方圆师兄
01-13 723
一段代码说明锁的作用 public class Test { private static int a; private static int b; private static int c; static Lock lock = new ReentrantLock(); private synchronized static void incrOfa() { a++; } private static void incrOfb() { b++; } private s
JUC-Synchronized
m0_62844645的博客
01-13 829
​ 这种切换会消耗大量资源，因为用户态和内核态都各自有各自专用的内存空间，寄存器等，用户态切换至内核态需要传递许多变量，参数给内核，内核也需要保护好用户态在切换时，一些寄存器值，变量等。以便内核态调用结束后切换回用户态。
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
Synchronized和Lock的区别 CountDownLatch/CyclicBarrier/Semaphore CountDownLatch 枚举类的使用 CyclicBarrier Semaphore 阻塞队列 SynchronousQueue Callable接口 阻塞队列的应用——生产者消费者 传统模式 阻塞...
JUC多线程学习个人笔记
07-08
原子操作：JUC提供了一些原子操作类，如AtomicInteger、AtomicLong等，可以实现线程安全的原子操作，避免了使用synchronized关键字的性能损耗。 锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁...
这就是标题—— JUC.pdf
05-19
Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程锁 并发下的集合类 List Set Map Callable接口 线程创建的方式 callable / runnable FutureTask JUC常用辅助类 ...
java并发编程-AQS和JUC实战
最新发布
04-29
synchronized，但从JDK6.0开始，JDK在synchronized上做了⼤量的优化，使得两者的性能差距并 不⼤。重⼊锁对逻辑控制的灵活性要远远好于synchronized。 之所以称之为重⼊锁，就是⼀个线程允许反复进⼊。当然，这⾥的...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 799
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 869
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1807
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
m0_46053885的博客
04-27 856
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1066
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 485
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
PageHelper实现分页查询
m0_63849044的博客
04-24 1113
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 353
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 730
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
synchronized JUC的区别
06-13
同时，JUC 的性能也更好，因为 JUC 中的锁实现都是基于 CAS（比较并交换）操作，而 synchronized 的实现是基于操作系统底层的互斥量。但是，使用 JUC 需要更加谨慎，因为如果使用不当可能会出现死锁、饥饿等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值