week6总结

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量61 收藏
点赞数
文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackrivan/article/details/126458804
版权
本文探讨了单例模式在并发编程中的挑战，特别是如何通过volatile和synchronized关键字保证线程安全，以及指令重排对代码有序性的影响。通过实例展示了双检锁的潜在问题，并深入解析了synchronized在不同场景下的同步机制。
摘要由CSDN通过智能技术生成

关于单例模式的一些思考

并发编程的有序性问题

**有序性：**顾名思义，有序性指的是程序按照代码的先后顺序执行。

导致代码不按照顺序执行的原因是指令重排。

​ 编译器为了优化性能，有时候会改变程序中语句的先后顺序。例如程序中：“a=6；b=7；” 编译器优化后可能变成 “b=7；a=6；”。在这个例子中，编译器调整了语句的顺序，这种调整顺序称为指令重排，指令重排不影响程序的最终结果。不过有时候编译器及解释器的优化可能导致意想不到的Bug。

Java 实现有序性的办法：

  • volatile 关键字可以禁止指令进行重排序优化，从而保证有序性
  • synchronized关键字可以保证共享变量的有序性
  • lock可以防止指令重排

示例：并发编程中的有序性问题

/**
 * 单例程序
 */
public class SingletonDemo {
    //定义一个instance，不new
    private  static SingletonDemo INSTANCE;

    //构造方法设为私有的，不让别人new
    private SingletonDemo() {
    }

    //提供一个getInstance方法
    public static SingletonDemo getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);//为了测试效果，休眠1毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new SingletonDemo();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        //100个线程创建单例对象，应该创建出来一个对象
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonDemo.getInstance().hashCode())).start();
        }
    }
}

分析代码：

​ 假设线程A在获取实例getInstance()的方法中，首先判断instance是否为空，如果为空则创建SingletonDemo的一个实例。但是在线程A判断和创建线程之间的这段时间里，来了线程B，线程B在获取实例getInstance()的方法中，判断instance也为空，结果导致线程B也创建了SingletonDemo的一个实例。运行该程序，观察运行结果，发现创建对象的hashCode值不同，说明不是一个对象，创建单例失败。

运行结果

​ 1343599390
​ 1926683415
​ 364927716
​ 112216044
​ 795884320

在Java领域一个经典的案例就是利用双重检查创建单例对象，例如下面的代码：

/**
 * 双重验证单例程序
 */
public class SingletonDemo {
    //定义一个instance，不new, 不使用volatile修饰变量instance
    private static SingletonDemo instance ;

    //构造方法设为私有的，不让别人new
    private SingletonDemo() {
    }

    //提供一个getInstance方法
    public static SingletonDemo getInstance() {
        //第一重验证
        if (instance  == null) {
            //对当前类加锁
            synchronized (SingletonDemo.class) {
                //第二重验证
                if (instance  == null) {
                    instance  = new SingletonDemo();
                }
            }
        }
        return instance ;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(SingletonDemo.getInstance().hashCode())
            ).start();
        }
    }
}
  • 在获取实例getInstance()的方法中，我们首先判断instance是否为空（第一重验证），如果为空，则锁定SingletonDemo.class并再次检查instance是否为空（第二重验证），如果还为空则创建Singleton的一个实例。
  • 假设有两个线程A、B同时调用getInstance()方法，他们会同时发现 instance == null（第一重验证） ，于是同时对SingletonDemo.class加锁，此时JVM保证只有一个线程能够加锁成功（假设是线程A），另外一个线程则会处于等待状态（假设是线程B）
  • 线程A会创建一个SingletonDemo实例，之后释放锁，锁释放后，线程B被唤醒，线程B再次尝试加锁，此时是可以加锁成功的，加锁成功后，线程B检查 instance == null 时会发现，已经创建过Singleton实例了，所以线程B不会再创建一个Singleton实例。

​ 这看上去一切都很完美，无懈可击，但实际上这个getInstance()方法并不完美。问题出在哪里呢？出在new操作上，我们以为的new操作应该是：

  1. 第一步：分配一块内存，地址为M
  2. 第二步：在内存M上初始化SingletonDemo对象
  3. 第三步：将M的地址赋值给instance变量

但是实际上编译器优化（指令重排）后的执行路径却是这样的：

  1. 第一步：分配一块内存，地址为M
  2. 第二步：将M的地址赋值给instance变量
  3. 第三步：在内存M上初始化SingletonDemo对象

第二步和第三步交换了顺序。

​ 优化后会导致什么问题呢？我们假设线程A先执行getInstance()方法，当执行完第二步时恰好发生了线程切换，切换到了线程B上；如果此时线程B也执行getInstance()方法，那么线程B在执行第一个判断时会发现 instance != null，所以直接返回instance，而此时的instance是没有初始化过的，如果我们这个时候访问 instance 的成员变量就可能触发空指针异常。
在这里插入图片描述

解决方法：用 volatile 修饰 instance。

volatile 修饰的变量在赋值时禁止指令重排。

将

private static SingletonDemo instance ;

修改为

private volatile static SingletonDemo instance ;//添加了 volatile 关键字，能防止指令重排

关于synchronized的一些思考

synchronized 同步代码块

  • 锁相同，可以实现同步
//锁相同，可以实现同步
public class Test01 {

    public static void main(String[] args) {
        Test01 obj = new Test01();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm();//使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm();//使用的锁对象this也是obj对象
            }
        }).start();
    }

    // 定义方法,打印 100 行字符串
    public void mm() {
        //这是临界区
        synchronized (this) {//经常使用this当前对象作为锁对象
            for (int i = 1; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + " --> " + i);
            }
        }
    }
}
  • 锁不同，不能实现同步
//锁不同，不能实现同步
public class Test02 {
    public static void main(String[] args) {
        Test02 obj = new Test02();
        Test02 obj2 = new Test02();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm();//使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.mm();//使用的锁对象 this 也是 obj2对象
            }
        }).start();
    }

    public void mm() {
        //这是临界区
        synchronized (this) {//经常使用this当前对象作为锁对象
            for (int i = 1; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + " --> " + i);
            }
        }
    }
}
  • 使用一个常量对象作为锁对象(可以实现同步)
// 使用一个常量对象作为锁对象(可以实现同步)
public class Test03 {
    public static void main(String[] args) {
        Test03 obj = new Test03();
        Test03 obj2 = new Test03();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm();//使用的锁对象 OBJ 常量
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj2.mm();//使用的锁对象 OBJ 常量
            }
        }).start();
    }

    public static final Object OBJ = new Object();

    //定义一个常量,
    public static void mm() {
        synchronized (OBJ) {//使用一个常量对象作为锁对象
            for (int i = 1; i <= 100; i++) {
                System.out.println(Thread.currentThread().getName() + " --> " + i);
            }
        }
    }
}

同步方法

  • 实例方法的锁是this
//把整个方法体作为同步代码块,默认的锁对象是 this 对象
public class Test05 {
    public static void main(String[] args) {
        Test05 obj = new Test05();   //obj是一把锁
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.mm2();            //使用的锁对象this就是obj对象
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Test05 obj1 = new Test05(); //新new的对象，产生了一把新的锁obj1
                obj1.mm2();           //obj1 和 obj不是同一个锁，不能实现同步 
                obj.mm2();            //使用的锁对象 this 也是 obj对象, 可以同步
            }
        }).start();
    }

    //使用 synchronized 修饰实例方法,同步实例方法, 默认 this 作为锁对象
    public synchronized void mm2() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + " --> " + i);
        }
    }
}
  • 静态方法的锁是类名.class
//把整个静态方法体作为同步代码块,默认的锁对象是当前类的运行时类对象, Test06.class, 有人称它为类锁
public class Test06 {
    public static void main(String[] args) {
        Test06 obj = new Test06();
        new Thread(new Runnable() {
            public void run() {
                obj.mm2();//使用的锁对象是 Test06.class
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Test06.mm2();//使用的锁对象是 Test06.class
            }
        }).start();
    }

    //使用 synchronized 修饰静态方法,同步静态方法, 默认运行时类作为锁对象
    public synchronized static void mm2() {//synchronized（Test06.class）
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + " --> " + i);
        }
    }
}

生产者消费者模式

在 Java 中，负责产生数据的模块是生产者，负责使用数据的模块是消费者。生产者消费者解决数据的平衡问题，即先有数据然后才能使用，没有数据时，消费者需要等待。

【单个生产者，单个消费者】

（1）定义能存放数据、能生产数据、能消费数据的类

//定义一个操作数据的类
class Data {
    //value是被操作的数据
    private String value = "";

    //生产数据的方法（就是给value赋值）
    public void setValue() {
        synchronized (this) {
            //单个生产者用if
            if (!value.equalsIgnoreCase("")) {
                try {
                    this.wait();//如果数据还没有被消费，就等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            String value = System.currentTimeMillis() + " - " + System.nanoTime();
            System.out.println("set 设置的值是: " + value);
            this.value = value;//生产者生产数据
            this.notifyAll();//生产者唤醒消费者
        }
    }

    //消费数据的方法（就是从value取值）
    public void getValue() {
        synchronized (this) {
            //单个消费者用if
            if (value.equalsIgnoreCase("")) {
                try {
                    this.wait();//如果数据还没有被生产，就等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("get 的值是: " + this.value);
            this.value = "";//消费者消费数据
            this.notifyAll();//消费者唤醒生产者
        }
    }
}

（2）定义生产者线程类

/**
 * 定义线程类模拟生产者
 */
class ProducerThread extends Thread {
    //定义存放数据的对象data
    private Data data;

    public ProducerThread(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            //生产者生产数据就是调用 Data 类的 setValue 方法给 value 字段赋值
            data.setValue();
        }
    }
}

（3）定义消费者线程类

// 定义线程类模拟消费者
class ConsumerThread extends Thread {
    //定义存放数据的对象data
    private Data data;

    public ConsumerThread(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            //消费者消费数据就是调用 Data 类的 getValue 方法获取 value 字段的值
            data.getValue();
        }
    }
}

定义测试类

//测试生产,消费的情况
public class Thread08 {
    public static void main(String[] args) {
        Data data = new Data();
        ProducerThread p = new ProducerThread(data);
        ConsumerThread c = new ConsumerThread(data);
        p.start();
        c.start();
    }
}

【多个生产者，多个消费者】

将生产数据的setValue()方法中的if修改为while就满足多个生产者

public void setValue() {
    synchronized (this) {
        //将单个生产者的if修改为while
        while (!value.equalsIgnoreCase("")) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String value = System.currentTimeMillis() + " - " + System.nanoTime();
        System.out.println("set 设置的值是: " + value);
        this.value = value;
        this.notifyAll();
    }
}

将消费数据的 getValue() 方法中的if修改为while就满足多个消费者

public void getValue() {
    synchronized (this) {
        //将单个消费者的if修改为 while
        while (value.equalsIgnoreCase("")) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("get 的值是: " + this.value);
        this.value = "";
        this.notifyAll();
    }
}

在测试类中创建多个生产者和消费者

public static void main(String[] args) {
    Data data = new Data();
    ProducerThread p1 = new ProducerThread(data);
    ProducerThread p2 = new ProducerThread(data);
    ConsumerThread c1 = new ConsumerThread(data);
    ConsumerThread c2 = new ConsumerThread(data);
    p1.start();
    p2.start();
    c1.start();
    c2.start();
}

execute() 和 submit()的区别

  1. 声明位置不同：
    1. execute() 方法定义在 Executor 接口中，submit() 方法定义在 ExecutorService 接口中
    2. ExecutorService 接口继承了 Executor 接口
  2. 可传参数不同：
    1. execute() 方法参数只能传入 Runnable 接口
    2. submit() 方法参数可以传入 Runnable 接口 和 Callable接口
  3. 返回值不同：
    1. execute() 方法没有返回值
    2. submit() 方法返回 future 类型的对象，通过 future 类型的对象可以获取线程的返回值
  4. 异常处理不同：
    1. submit() 方法内部处理了线程运行期间抛出的异常，导致开发人员看不到线程是否发生了异常
    2. execute() 方法没有处理线程运行期间抛出的异常，线程发生异常会抛给出来
      p2.start();
      c1.start();
      c2.start();
      }
jackrivan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学习总结week6_1excel入门
m0_72819241的博客
08-22 1314
总结
Java基础学习总结
农村小白的博客
02-21 3315
Java基础知识总结，在学习这一门语言新知识点新技术的过程中很枯燥很不容易很有压力，但它必须要经历这些过程，它就是要从认识、模仿、练习、总结、理解与掌握并实际运用的历程；废话少说，请看以下详细文档： 一、基本概念： 1、java语言特点：简单、面向对象、分布式、解析型、稳定、安全、结构中立、易移值、高性能、多线程、动态语言.... 2、java环境的搭建 cmd运行java文件 jdk与...
Week1学习总结
weixin_46020795的博客
07-24 5439
Week1学习总结 Python优缺点 解释性语言，可移植性，跨平台 面向对象编程 语法简洁，可读性高 开源，强大的生态圈 运行效率低 源码加密难 变量 什么是变量? 变量是数据的载体 变量的命名规则 变量以字母,数字,下划线命名,其中数字不能开头 变量区分大小写(S和s不是统一变量) 不能用Python的关键字(Python中一些特殊含义的单词)和保留字命名(Python中已使用的单词) 关键字如图所示: 建议使用规则 见名之意（看到变量名字，就代表它什么意思） 变量名使用全
ZROI week6
aijiu8213的博客
01-23 125
ZROI week6 T1 用一个类似背包的东西记录答案。 T2 好像直接用|操作即可。 T3 瞎搞就完事了 T4 启发式合并，然而变量写错了，就没了。。。 总结 100 + 100 + 100 + 0 = 300 转载于:https://www.cnblogs.com/akoasm/p/10306998.html...
坑人的 week 集成
我就是小伟哥的专栏
12-07 822
文章目录坑人的 week 集成坑1坑2坑3坑4坑5 6 7 ...正确姿势总结 坑人的 week 集成 本人经过两天的时间终于把 week 集成到了项目之中，中间经过了非人的折磨，躺了无数的坑，进一个坑，把项目删了，告诉我这条路走不通，换条路接着走，扑街之后，在进行下一个方式。简单的把我错误的方式介绍下，避免后人趟坑，最后把我成功的方式贴出来供大家参考。 坑1 看官网介绍，兴冲冲的看到了一种方式，...
【WEEK6】学习目标及总结【MySQL】【中文版】
2401_83329143的博客
04-01 254
两周完成MySQL的学习——第二周。
信息系统安全实验——Week 6
Coco_T的博客
04-08 4532
T1.审计过滤 题目描述 浏览器进入靶机IP地址首页，并借助靶机IP/Source.txt所提供的首页源码，尝试构造合适的number过滤掉所有的限制条件，找到flag！ 操作机：1.7.197.2 靶机：1.7.197.3 查看1.7.197.3/Source.txt <?php $info = ""; $req = []; $flag="xxxxx"; ini_set("display_error", false); //为一个配置选项设置值 error_reporting(0); /
[week5]每周总结与工作计划
水果君の日常
10-08 1600
其实上周日晚上我正在准备从老家回学校的行李，所以总结规划留到现在才写~      我不得不说，国庆回到老家，我几乎什么事都没做Orz。。。      所以安排的任务全部没完成Orz，就看了几个itercast的视频，倒是把亲朋好友的门串了个遍（还看了20多卷的漫画Orz）。。。      感觉好颓废啊，得调整状态了。      这周只剩下6天了，周六还要补课，所以任务安排少一点。 于是不
week report 2015.12.6
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
12-12 1076
Week Report 2015.12.6 一、English：     1、plan and try as I can to do something help grade 10 and grade 11.     2、singing the songs time at 9:00-9:20 is great ,I can totally open my mont
[week6]每周总结与工作计划
水果君の日常
10-14 1375
安排一下每天的时间，分配一下课余时间认真地刷小白的dp题目背单词、马克思、练硬笔书法学日语itercast的linux磁盘基础学完，sql也看一下看完Randy Pausch的演讲，收集演讲Head First Java第5章计算机网络+操作系统的学习安排看csapp和各种书~ 这周竟然只写了一篇文章。。。Orz我快废了。。。 这周沉迷于coursera的公开课中，roll了好几个公开课，都不
Moringa-Core-Week-6-IP
02-13
标题"Moringa-Core-Week-6-IP"指的是一个学习项目，可能是在Moringa学习机构的第六周核心课程中的一个编程作业，专注于数据分析。这个项目利用多项式回归来预测足球队的进球数量，这是一种机器学习技术，用于建立...
EE660-H2-W5-F22 week6
06-25
【EE660-H2-W5-F22 week6】本周的主题主要集中在机器学习的相关概念和理论，包括概率计算、误差率分析、VC维、模型复杂度与泛化能力、线性回归以及偏差与方差的理解。 1. 题目1.7 a. 该部分涉及到概率计算。给定了...
week 6-贸易函电书写规范.pdf
05-30
6. 称呼（The salutation）：称呼是对收信人的问候，如“Dear Sirs”、“Dear Madam”或“Dear Mr./Ms. XX”。冒号或逗号皆可作为称呼后的标点，首字母需大写。对于熟悉的人，可直呼其名。 7. 事由（The subject ...
Week4
03-05
总结来说，在Week4的学习中，你将全面掌握HTML的基本语法，元素，属性，以及HTML5的新特性。通过实际编写和理解代码，你将能够创建出结构清晰、内容丰富的静态网页，并为进一步学习网页动态化和响应式设计打下坚实...
C++-boost库总结.doc
12-21
6. date_duration：表示天精度的时间间隔概念，别名为days，另外还有years、months、weeks。 7. date_period：表示两个date之间的日期区间（精度到天的 TimeSpan）。 8. date_iterator、week_iterator、month_...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 538
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 862
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 533
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 241
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
宇宙航天科技工作总结：星球探索PPT模板
6. **周进度条**：模板中的周进度展示部分，如"WEEK1"到"WEEK4"，是用于可视化工作进度或者任务完成情况的有效工具，可以直观地呈现周期性工作的进展。 7. **支持文本**：模板的各部分都有预留的“Supporting text ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值