Java多线程编程核心技术---单例模式与多线程

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量113 收藏
点赞数
文章标签： java 数据库 设计模式
原文链接：http://www.cnblogs.com/umgsai/p/5600109.html
版权
立即加载/饿汉模式

立即加载就是使用类的时候已经将对象创建完毕。

public class MyObject {
    //立即加载方式==饿汉模式
    private static MyObject myObject = new MyObject();
    private MyObject(){
    }
    public static MyObject getInstance(){
        //立即加载
        //缺点是不能有其他实例变量
        //getInstance()方法没有同步，有可能出现非线程安全问题
        return myObject;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行程序，控制台打印结果如下：

1795478472
1795478472
1795478472

控制台打印的hashCode是同一个值，说明对象是同一个，也就实现了立即加载型单例模式。

延迟加载/懒汉模式

延迟加载就是在调用get()方法时实例才被创建

public class MyObject {
    private static MyObject myObject;
    private MyObject(){
    }
    public static MyObject getInstance() {
        //延迟加载
        if (myObject != null) {
            return myObject;
        }
        myObject = new MyObject();
        return myObject;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

程序运行结果如下：

1396452035

此实验虽然取得一个对象的实例，但是如果是在多线程环境中，就会出现取出多个实例的情况。对以上代码中的main函数做如下修改：

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

重新运行程序，控制台打印结果如下：

166471260
1795478472
1858758426

控制台打印了三个不同的hashCode，说明并没有实现单例模式。

延迟加载/懒汉模式 解决方案
public class MyObject {
    private static MyObject myObject;
    private MyObject(){
    }
    //整个方法上锁，效率较低
    synchronized public static MyObject getInstance() {
        //延迟加载
        if (myObject != null) {
            return myObject;
        }
        try {
        //模拟一些耗时操作
                Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myObject = new MyObject();
        return myObject;
    }
}

重新运行程序，控制台将打印出三个一样的hashCode。

以上方法对整个方法加锁，效率比较低。对以上代码做如下修改：

public class MyObject {
    private static MyObject myObject;
    private MyObject(){
    }
    public static MyObject getInstance() {
        //延迟加载
        if (myObject != null) {
            return myObject;
        }
        try {
            //模拟一个耗时操作
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (MyObject.class) {
            myObject = new MyObject();
        }
        return myObject;
    }
}

重新运行程序，控制台打印结果如下：

774088025
641502649
1367113803

以上代码虽然解决的效率问题，但是仍然没有保证只创建一个实例。继续对以上代码做如下修改：

public class MyObject {
    private static MyObject myObject;
    private MyObject(){
    }
    public static MyObject getInstance() {
        //延迟加载
        if (myObject != null) {
            return myObject;
        }
        try {
            //模拟一个耗时操作
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (MyObject.class) {
            if (myObject == null) {
                myObject = new MyObject();
            }
        }
        return myObject;
    }
}

重新运行程序，控制台输入结果如下：

641502649
641502649
641502649

使用双重检查锁(DCL)功能，成功解决了懒汉模式遇到的多线程问题。DCL也是大多数多线程结合单例模式使用的解决方案。

使用静态内置类实现单例模式
public class MyObject {
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }
    private MyObject(){
        
    }
    public static MyObject getInstance () {
        return MyObjectHandler.myObject;
    }
}

运行程序，控制台输出结果如下：

774088025
774088025
774088025
序列化与反序列化的单例模式实现
public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }
    private MyObject(){
        
    }
    public static MyObject getInstance () {
        return MyObjectHandler.myObject;
    }
}

public class SaveAndRead {
    public static void main(String[] args) {
        try {//序列化对象到磁盘
            MyObject myObject = MyObject.getInstance();
            FileOutputStream fileOutputStream = new FileOutputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));
            ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutputStream);
            objectOutput.writeObject(myObject);
            objectOutput.close();
            fileOutputStream.close();
            System.out.println(myObject.hashCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
        /****************/
        try {//从磁盘反序列化到对象
            FileInputStream fileInputStream = new FileInputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            MyObject myObject = (MyObject) objectInputStream.readObject();
            objectInputStream.close();
            fileInputStream.close();
            System.out.println(myObject.hashCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行程序，控制台打印结果如下：

988487739
1878277481

控制台打印出的hashCode不同，存储到磁盘上的对象和从磁盘读取出来的对象并不是同一个对象。对以上代码做如下修改：

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }
    private MyObject(){
        
    }
    public static MyObject getInstance () {
        return MyObjectHandler.myObject;
    }
    protected Object readResolve(){
        System.out.println("readResolve invoked");
        return MyObjectHandler.myObject;
    }
}

重新运行程序，控制台打印结果如下：

1066557918
readResolve invoked
1066557918

反序列化时使用了ReadResolve()方法，存储到磁盘上的对象和从磁盘上取出来的对象是同一个对象。

使用static代码块实现单例模式

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性来实现单例模式。

public class MyObject {
    private static MyObject myObject = null;
    private MyObject(){
        
    }
    static{
        myObject = new MyObject();
    }
    public static MyObject getInstance() {
        return myObject;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(MyObject.getInstance().hashCode());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行程序，控制台输出结果如下：

708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873
使用enum枚举数据类型实现单例模式

枚举enum和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以实现单例设计模式。

public enum MyObject {
    connectionFactory;
    private Connection connection;
    private MyObject(){
        try {
            System.out.println("创建MyObject对象");
            String url = "jdbc:mysql://127.0.0.1:3306/test";
            String user = "root"; 
            String password = "";
            String driver = "com.mysql.jdbc.Driver";
            Class.forName(driver);
            connection = DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public Connection getConnection() {
        return connection;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(MyObject.connectionFactory.getConnection().hashCode());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行程序，控制台打印结果如下：

创建MyObject对象
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
完善使用enum枚举实现单例模式

上面的代码中将枚举类进行了暴露，违反了“职责单一原则”。下面进行改善：

public class MyObject {
    public enum MyEnumSingleton{
        connectionFactory;
        private Connection connection;
        private MyEnumSingleton(){
            try {
                System.out.println("创建MyObject对象");
                String url = "jdbc:mysql://127.0.0.1:3306/test";
                String user = "root"; 
                String password = "";
                String driver = "com.mysql.jdbc.Driver";
                Class.forName(driver);
                connection = DriverManager.getConnection(url, user, password);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        public Connection getConnection() {
            return connection;
        }   
    }
    public static Connection getConnection() {
        return MyEnumSingleton.connectionFactory.getConnection();
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(MyObject.getConnection().hashCode());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果如下：

创建MyObject对象
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480

转载于:https://www.cnblogs.com/umgsai/p/5600109.html

G19931112
关注
Java多线程编程核心技术 —— 单例模式与多线程
良月柒
12-09 239
1、立即加载 / “饿汉模式”，立即记载就是使用类的时候已经将对象创建完毕，常见的实现方法就是直接new 实例化。而立即加载从中文的语境来看，有“着急”、“急迫”的含义，所以也称“饿汉模式”。立即加载 / “饿汉模式”是在调用方法前，实例已经被创建了。   2、延迟加载 / “懒汉模式”，延迟加载就是在调用get()方法时实例才被创建，常见的实现方法就是在get()方法中进行new 实例化。而...
单例模式-多线程解决方案1
Nuan_Feng的博客
02-23 711
package E_Singleton.thread;/** * 多线程解决方案1 * 缺点：只有第一次执行方法时才需要同步，设置好uniqueInstance变量，不再需要sync了，之后每次调用都浪费资源 * * @author Administrator * */ public class Singleton1 { private static Singl
单例模式-多线程解决方案2
Nuan_Feng的博客
02-23 351
package E_Singleton.thread;/** * 多线程解决方案2:不采用延迟实例化 * * @author Administrator * */ public class Singleton2 { private static Singleton2 uniqueInstance = new Singleton2();private Singleto
单例模式完全剖析(1)---- 探究简单却又使人迷惑的单例模式
maqj的专栏
11-09 1387
概要单例模式是最简单的设计模式之一，但是对于Java的开发者来说，它却有很多缺陷。在本月的专栏中，David Geary探讨了单例模式以及在面对多线程（multithreading)、类装载器（classloaders）和序列化(serialization)时如何处理这些缺陷。单例模式适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统，它们都是原型的例子。典型的情况是，那些对象的
单例模式与多线程
Dream it Possible
06-08 536
本篇博客主要探讨一个问题：如何使单例模式遇到多线程是安全的、正确的。 【立即加载/饿汉模式】 立即加载就是在调用方法前，实例已经被创建了，常见的方法是直接new实例化。实例代码，如下： MyObject.java: public class MyObject { // 立即加载方式==饿汉模式 private static MyObject myObject = new MyOb
java 多线程编程实战指南（核心 + 设计模式 完整版）
03-20
《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧，分为核心篇和设计模式篇，旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**：Java提供了两种创建线程...
Java多线程实战之单例模式与多线程的实例详解
08-26
单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、懒汉模式等。下面我们将详细讨论Java多线程实战...
java多线程之线程安全的单例模式
09-02
在Java编程中，单例模式是一种常见的设计模式，它保证了类只有一个实例，并提供全局访问点。在多线程环境下，线程安全的单例模式尤其重要，因为如果不正确地实现，可能会导致多个线程创建多个实例，违反了单例模式的...
Java多线程下的单例模式参考
09-02
本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`ReentrantLock`类。 首先，我们来看传统的懒汉式单例模式，它延迟初始化，只有在第一次调用`...
Java 单例模式线程安全问题
08-29
然而，在多线程环境下，单例模式可能会遇到线程安全问题，因为多个线程可能会同时访问同一个实例，从而导致数据不一致和其他问题。 在 Java 中，单例模式的实现可以使用双重检查锁机制、静态内部类和枚举类型等方式...
你所不知道的单例模式和多线程并发在单例模式中的影响
热门推荐
a_lonely_dancer的博客
09-06 1万+
本博客是根据一篇博客修改的。因为原文博客对于菜鸟不是很易理解，所以在这里加了点东西单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。3、有些类如交易所的核心交易引擎，控制着交
单例模式解决多线程的问题
gghh2015的博客
11-04 1344
1、懒汉模式把getInstance()方法变成同步方法 public class Singleton{ private static Singleton singleton; private Singleton(){} public static synchronized Singleton getInstance(){ if(singleton == null){ singl
单例模式（Singleton）--遇到多线程时的问题
Lunar_Queen的博客
08-17 923
前面讲述了单例模式的基本概念：https://blog.csdn.net/Lunar_Queen/article/details/81774016。 然而，在多线程环境下，前面的程序段并不能保证真正的“单例”。 示例代码如下： #include&amp;lt;iostream&amp;gt; #include&amp;lt;Windows.h&amp;gt; #include&amp;lt;process.h&amp;gt; usin...
多线程下的单例模式实现
bajianxiaofendui的博客
02-11 1万+
多线程下的单例模式实现一，单线程下的单实例1， 懒汉模式2， 饿汉模式二，多线程下的单实例1，加锁2，原子操作 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;单实例设计模式是我们平常接触最多的一种设计模式，它的特点在于保证一个类只有一个实例，并且对类成员的访问都是通过一个全局访问点来进行的。单实例主要用在整个场景中只能有一个该操作类对象，不允许再有其他的该操作类对象，比如：Http传...
单例模式在多线程情况下出现的问题以及双重加锁机制(DCL)解决问题
weixin_43156133的博客
07-19 998
单例模式代码： private static ShuangChongJiaSuo instance=null; private ShuangChongJiaSuo(){ System.out.println(Thread.currentThread().getName()+"\t 我是构造方法"); } public static synchronized ShuangChongJiaSuo getInstance(){ if(instance==
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 338
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 862
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 906
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
Java多线程编程：单例模式与线程休眠深度解析
"该资源是一本关于计算机网络原理的自考教材，涵盖了线程的休眠和单例模式等内容，适合 Java 多线程编程学习。书中由汪文君撰写，详细介绍了 Java 多线程的各个方面，包括线程的创建、状态以及单例模式的应用。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值