单例模式与多线程

最新推荐文章于 2020-01-23 17:21:53 发布
最新推荐文章于 2020-01-23 17:21:53 发布
阅读量305 收藏
点赞数
分类专栏： J2EE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zongzhankui/article/details/79372344
版权

本文的知识点非常重要，通过单例模式与多线程技术相结合，在这个过程中能发现很多以前未考虑过的情况，一些不良的程序设计方法如果应用在商业项目中，将会遇到非常大的麻烦。本文的案例也将充分说明，线程与某些技术相结合时要考虑的事情有很多。在学习本文时只需要考虑一件事情，那就是：如何使单例模式遇到多线程是安全的、正确的。

在标准的23个设计模式中，单例设计模式在应用中是比较常见的。但在常规的该模式教学资料介绍中，多数并没有结合多线程技术作为参考，这就造成在使用多线程技术的单例模式时会出现一些意想不到的情况，这样的代码如果在生产环境中出现异常，有可能造成灾难性的后果。本文将介绍单例模式结合多线程技术在使用时的相关知识。

1. 立即加载/“饿汉模式”

什么是立即加载？立即加载就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new实例化。而立即加载从中文的语境来看，有“着急”、“急迫”的含义，所以也称为“饿汉模式”。
立即加载/“饿汉模式”是在调用方法前，实例已经被创建了，来看一下实现代码。

创建测试用的项目，创建类MyObject.java代码如下：

public class MyObject {

    // 立即加载方式==饿汉模式
    private static MyObject myObject = new MyObject();

    private MyObject() {
    }

    public static MyObject getInstance() {
        // 此代码版本为立即加载
        // 此版本代码的缺点是不能有其它实例变量
        // 因为getInstance()方法没有同步
        // 所以有可能出现非线程安全问题
        return myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

1031548957
1031548957
1031548957

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

2. 延迟加载/“懒汉模式”

什么是延迟加载？延迟加载就是在调用get()方法时实例才被创建，常见的实现办法就是在get()方法中进行new实例化。而延迟加载从中文的语境来看，是“缓慢”、“不急迫”的含义，所以也称为“懒汉模式”。

2.1 延迟加载/“懒汉模式”解析

延迟加载/“懒汉模式”是在调用方法时实例才被创建。一起来看一下实现代码。

创建类MyObject.java代码如下：

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

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

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

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

}

程序运行后的效果如下：

1031548957

此实验虽然取得一个对象的实例，但如果是在多线程的环境中，就会出现去除多个实例的情况，与单例模式的初衷是相背离的。

2.2 延迟加载/“懒汉模式”的缺点

前面两个实验虽然使用“立即加载”和“延迟加载”实现了单例设计模式，但在多线程的环境中，前面“延迟加载”示例中的代码完全就是错误的，根本补鞥呢实现保持单例的状态。来看一下如何在多线程环境中结合“错误的单例模式”创建出“多例”。
创建类MyObject.java代码如下：

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的效果如下：

186668687
903341402
1770731361

控制台打印出了3中hashCode，说明创建了3个对象，并不是单例的，这就是“错误的单例模式”。如何解决呢？先看一下解决方案。

2.3 延迟加载/“懒汉模式”的解决方案

2.3.1 声明synchronized关键字

既然多个线程可以同时进入getInstance()方法，那么只需要对getInstance()方法声明synchronized关键字即可。

创建类MyObject.java代码如下：

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

    // 设置同步方法效率太低了
    // 整个方法被上锁
    synchronized public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

531436928
531436928
531436928

此方法加入同步synchronized关键字得到相同实例的对象，但此种方法的运行效率非常低下，是同步运行的，下一个线程想要取得对象，则必须等上一个线程释放锁之后，才可以继续执行。

2.3.2 尝试同步代码块

同步方法是对方法的整体进行持锁，这对运行效率来讲是不利的。改成同步代码块能解决吗？

创建类MyObject.java代码如下：

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

    public static MyObject getInstance() {
        try {
            // 此种写法等同于：
            // synchronized public static MyObject getInstance()
            // 的写法，效率一样很低，全部代码被上锁
            synchronized (MyObject.class) {
                if (myObject != null) {
                } else {
                    // 模拟在创建对象之前做一些准备性的工作
                    Thread.sleep(3000);

                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

        // 此版本代码虽然是正确的
        // 但public static MyObject getInstance()方法
        // 中的全部代码都是同步的了，这样做有损效率
    }

}

程序运行后的结果如下：

903341402
903341402
903341402

此方法加入同步synchronized语句块得到相同实例的对象，但此种方法的运行效率也是非常低的，和synchronized同步方法一样是同步运行的。继续更改代码尝试解决这个缺点。

2.3.3 针对某些重要的代码进行单独的同步

同步代码块可以针对某些重要的代码进行单独的同步，而其他的代码则不需要同步。这样在运行时，效率完全可以得到大幅提升。

创建MyObject.java代码如下：

public class MyObject {

    private static MyObject myObject;

    private MyObject() {
    }

    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                // 使用synchronized (MyObject.class)
                // 虽然部分代码被上锁
                // 但还是有非线程安全问题
                synchronized (MyObject.class) {
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

903341402
1770731361
1684444739

此方法使同步synchronized语句块，只对实例化对象的关键代码进行同步，从语句的结构上来讲，运行的效率的确得到了提升。但如果是遇到多线程的情况下无法解决得到同一个实例对象的结果。到底如何解决“懒汉模式”遇到多线程的情况呢？

2.3.4 使用DCL双检查锁机制

在最后的步骤中，使用的是DCL双检查锁机制来实现多线程环境中的延迟加载单例设计模式。

创建类MyObject.java代码如下:

public class MyObject {

    private volatile static MyObject myObject;

    private MyObject() {
    }

    // 使用双检测机制来解决问题
    // 即保证了不需要同步代码的异步
    // 又保证了单例的效果
    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    if (myObject == null) {
                        myObject = new MyObject();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
    // 此版本的代码称为：
    // 双重检查Double-Check Locking

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {


        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

186668687
186668687
186668687

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

3. 使用静态内置类实现单例模式

DCL可以解决多线程单例模式的非线程安全问题。当然，使用其他的办法也能达到同样的效果。

创建类MyObject.java代码如下：

public class MyObject {

    // 内部类方式
    private static class MyObjectHandler {
        private static MyObject myObject = new MyObject();
    }

    private MyObject() {
    }

    public static MyObject getInstance() {
        return MyObjectHandler.myObject;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

}

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

531436928
531436928
531436928

4. 序列化与反序列化的单例模式实现

静态内置类可以达到线程安全问题，但如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。

创建MyObject.java代码如下：

import java.io.ObjectStreamException;
import java.io.Serializable;

public class MyObject implements Serializable {

    private static final long serialVersionUID = 888L;

    // 内部类方式
    private static class MyObjectHandler {
        private static final MyObject myObject = new MyObject();
    }

    private MyObject() {
    }

    public static MyObject getInstance() {
        return MyObjectHandler.myObject;
    }

    protected Object readResolve() throws ObjectStreamException {
        System.out.println("调用了readResolve方法！");
        return MyObjectHandler.myObject;
    }

}

创建业务类SaveAndRead.java代码如下：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import test.MyObject;

public class SaveAndRead {

    public static void main(String[] args) {
        try {
            MyObject myObject = MyObject.getInstance();
            FileOutputStream fosRef = new FileOutputStream(new File(
                    "myObjectFile.txt"));
            ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
            oosRef.writeObject(myObject);
            oosRef.close();
            fosRef.close();
            System.out.println(myObject.hashCode());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        try {
            FileInputStream fisRef = new FileInputStream(new File(
                    "myObjectFile.txt"));
            ObjectInputStream iosRef = new ObjectInputStream(fisRef);
            MyObject myObject = (MyObject) iosRef.readObject();
            iosRef.close();
            fisRef.close();
            System.out.println(myObject.hashCode());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

程序运行后的效果如下：

1836019240
81628611

解决办法就是在反序列化中使用readResolve()方法。
去掉如下代码的注释：

    protected Object readResolve() throws ObjectStreamException {
        System.out.println("调用了readResolve方法！");
        return MyObjectHandler.myObject;
    }

程序运行后的结果如下：

1836019240
调用了readResolve方法！
1836019240

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

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

创建MyObject.java代码如下：

public class MyObject {

    private static MyObject instance = null;

    private MyObject() {
    }

    static {
        instance = new MyObject();
    }

    public static MyObject getInstance() {
        return instance;
    }

}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();

    }

}

程序运行后的结果如下：

186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687
186668687

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

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

创建类MyObject.java代码如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public enum MyObject {
    connectionFactory;

    private Connection connection;

    private MyObject() {
        try {
            System.out.println("调用了MyObject的构造");
            String url = "jdbc:mysql://localhost:3306/test";
            String username = "root";
            String password = "root";
            String driverName = "com.mysql.jdbc.Driver";
            Class.forName(driverName);
            connection = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public Connection getConnection() {
        return connection;
    }
}

创建线程类MyThread.java代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

创建运行类Run.java代码如下：

import extthread.MyThread;

public class Run {

    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的构造
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510
482793510

7. 完善使用enum枚举实现单例模式

前面一节将枚举类进行暴露，违反了“职责单一原则”，在本节中进行完善。

更改类MyObject.java代码如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MyObject {

    public enum MyEnumSingleton {
        connectionFactory;

        private Connection connection;

        private MyEnumSingleton() {
            try {
                System.out.println("创建MyObject对象");
                String url = "jdbc:mysql://localhost:3306/test";
                String username = "root";
                String password = "root";
                String driverName = "com.mysql.jdbc.Driver";
                Class.forName(driverName);
                connection = DriverManager.getConnection(url, username,
                        password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        public Connection getConnection() {
            return connection;
        }
    }

    public static Connection getConnection() {
        return MyEnumSingleton.connectionFactory.getConnection();
    }

}

更改MyThread.java类代码如下：

import test.MyObject;

public class MyThread extends Thread {

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

程序运行的结果如下：

创建MyObject对象
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
2007882269
黑土墨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程--单例模式
m0_58430482的博客
04-30 2030
多线程--单例模式详解
多线程环境下的单例模式
m0_62547912的博客
12-05 1835
适用多线程环境的单例模式
彻头彻尾理解单例模式与多线程
热门推荐
Rico's Blogs
03-20 3万+
本文概述了单例模式产生动机，揭示了单例模式的本质和应用场景。然后我们给出了单例模式在单线程环境下的两种经典实现：饿汉式和懒汉式，但是饿汉式是线程安全的，而懒汉式是非线程安全的。在多线程环境下，我们特别介绍了五种方式来在多线程环境下创建线程安全的单例，使用synchronized方法、synchronized块、静态内部类、双重检查和ThreadLocal实现懒汉式单例，并给出实现效率高且线程安全的单例所需要注意的事项
设计模式之—单例模式
程序员王老五
09-14 312
定义：单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。 应用场景： 单例模式的经典使用场景： 1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 2.控制资源的情况下，方便资源之间的互相通信。如线程池等。 应用场景举例：
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
QT单例模式、多线程、双重校验加锁
最新发布
06-11
在QT中，单例模式、多线程以及双重校验加锁（Double-Checked Locking）是常见的编程模式和技术，尤其在处理并发和资源管理时显得尤为重要。 **单例模式** 是一种设计模式，确保一个类只有一个实例，并提供一个全局...
JAVA多线程并发下的单例模式应用
08-31
JAVA多线程并发下的单例模式应用 单例模式是设计模式中比较简单的一个，也是非常常见的，但是在多线程并发的环境下使用却是不那么简单了。今天我们将分享一个在开发过程中遇到的单例模式的应用。 单例模式的定义：...
Java多线程下的单例模式参考
09-02
在多线程环境中，实现单例模式时需要特别注意线程安全问题，以防止在并发访问时产生多个实例。本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`...
C++ 多线程和多线程下的单例模式
01-08
本资源描述了C++11 中多线程的创建，C++11中std命名空间中将boost库中的Thread加入，boost多线程从准标准变为标准，其中还介绍了C++ 多线程下的单例模式的使用，本文档为txt文档
你所不知道的单例模式和多线程并发在单例模式中的影响
a_lonely_dancer的博客
09-06 1万+
本博客是根据一篇博客修改的。因为原文博客对于菜鸟不是很易理解，所以在这里加了点东西单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。3、有些类如交易所的核心交易引擎，控制着交
懒汉单例模式在多线程下的应用
c1052981766的专栏
12-22 344
1.懒汉单例模式，是在使用时判断对象是否存在，因此，是非线程安全的，需要通过添加synchronized对创建对象部分加锁； 如何加锁：               1.首先想到的是在getInstance方法加锁；       如：  public static synchronized getInstance(){  if(null  == obj ){ obj = new 类名()
java 单例模式与多线程
ty_laurel的博客
07-14 382
什么是单例模式 单例模式是一种创建型模式，某个类在采用了单例模式，在该类创建后，只能产生一个实例供外部访问，并且提供一个全局的访问点。数据库连接池的设计一般就是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要就是节省打开或关闭数据路连接所引起的效率损耗，使用单例模式，就可以大大降低这些损耗 饿汉模式 饿汉模式也称为立即加载，即就是使用类的时候已
单例模式在多线程中的安全性研究
weixin_30387799的博客
04-06 184
概述 关于一般单例模式的创建和分析在我的另一篇博客《Java设计模式——单件模式》中有详细说明。只是在上篇博客中的单例是针对于单线程的操作，而对于多线程却并不适用，本文就从单例模式与多线程安全的角度出发，讲解单例模式在多线程中应该如何被使用。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Coding-Naga ...
C++单例模式与多线程安全
PPprogrammer的博客
01-23 1905
用代码实现如下： class Singleton { public: static Singleton* CreateObj() { if (m_pInstance == NULL) { m_pInstance = new Singleton(); } return m_pInstance; } void test() { cout << "访问单例类的接...
java多线程编程核心技术6-单例模式与多线程
wangwei249的博客
04-01 254
前言：本章的知识非常重要，通过单例模式与多线程技术相结合，在这个过程中能发现很多以前从未考虑过的情况，一些不良的程序设计方法如果应用在商业       项目中，将会遇到非常大的麻烦。 考虑：如何使单例模式遇到多线程是安全的、正确的。 一。立即加载/饿汉模式 1.立即加载就是使用类的时候已经将对象创建完毕，类加载的时候就已经创建了对象。     public class MyObj
如何理解 servlet 的单实例多线程
李威威的博客
08-21 1876
如何理解 servlet 的单实例多线程 http://blog.csdn.net/nieyinyin/article/details/7470576
单例模式在多线程中最经典的两种方式
Mr_YarNell的博客
09-29 471
这两种方式在提高性能的同时又保证了线程安全   第一种：static inner class 静态内部类(饿汉式)：   public class StringTest { public static class Singltion{ private static Singltion singltion=new Singltion(); public static Singltion...
掌握单例模式与多线程安全实践
"单例模式详解深入解析" 在IT领域，单例模式...在IDEA环境下，熟练掌握多线程调试有助于更好地排查和优化单例模式的并发问题。掌握这些知识点将有助于提升技术面试的表现，增强项目开发中的代码质量和效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值