(Java多线程学习)单例模式与多线程

最新推荐文章于 2025-03-20 19:34:52 发布
原创 最新推荐文章于 2025-03-20 19:34:52 发布 · 590 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java多线程

本文深入探讨了单例模式在多线程环境下的实现方法，包括立即加载（饿汉模式）、延迟加载（饱汉模式），以及使用静态内置类、枚举等实现线程安全的单例模式。

单例模式在应用中比较常见，比如我们的web系统中service层和dao层的对象就是单例模式，如果控制层采用的是struts的话是多例模式，如果是SpringMVC的话就是单例模式。（这里涉及的是spring的作用域）

 　　本文主要研究在多线程环境中如何确保在多线程环境下使用单例模式是安全的、正确的。

1.立即加载/"饿汉模式"

　　立即加载就是使用类的时候已经将对象创建完毕，常用的办法就是直接new实例化。而立即记载从中文的语境来看，有"着急","迫切"的意思，所以也称为饿汉模式。

一个简单的立即加载的代码:

复制代码

package cn.qlq.thread.fifteen;
/**
 * 立即加载==饿汉模式
 * @author Administrator
 *
 */
public class Singleton_1 {
    
    private static Singleton_1 instance = new Singleton_1();
    
    private Singleton_1 () {
    }
    
    public static Singleton_1 getInstance(){
        //缺点是不能有其他实例变量，因为此方法没有同步所以有可能出现线程非安全问题
        return instance;
    }
}

复制代码

测试的话开启多个线程打印getInstance()返回对象的hashCode即可。

 

2.延迟加载/"饱汉模式"

　　延迟加载就是在调用get方法的时候才创建对象，常见的办法就是在get中new对象。延迟加载有缓慢、不急迫的意思，因此被称为"饱汉模式"。

1.一种简单的写法:(多线程中出现多个实例)

复制代码

package cn.qlq.thread.fifteen;
/**
 * 延迟加载==饱汉模式
 * @author Administrator
 *
 */
public class Singleton_2 {
    
    private static Singleton_2 instance ;
    
    private Singleton_2 () {
    }
    
    public static Singleton_2 getInstance(){
        if(instance == null){
            instance = new Singleton_2();
        }
        return instance;
    }
}

复制代码

　　上面代码在单线程环境下是正确的，但是在多线程环境下很可能出现取出多个实例的情况。

 

一种多线程环境下的延迟加载出现多个实例的例子:

复制代码

package cn.qlq.thread.fifteen;

/**
 * 延迟加载==饱汉模式
 * 
 * @author Administrator
 *
 */
public class Singleton_2 {

    private static Singleton_2 instance;

    private Singleton_2() {
    }

    public static Singleton_2 getInstance() {
        try {
            if (instance == null) {
                // 模拟处理其他事情
                Thread.sleep(3 * 1000);
                instance = new Singleton_2();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton_2.getInstance().hashCode());
            }
        };
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }
}

复制代码

结果:

713786339
713786339
763347431

 

2.解决方案

2.1 声明synchronized关键字:

复制代码

    public static synchronized Singleton_2 getInstance() {
        try {
            if (instance == null) {
                // 模拟处理其他事情
                Thread.sleep(3 * 1000);
                instance = new Singleton_2();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }

复制代码

　　将getInstance方法加synchronized关键字修饰，同步整个方法，使得效率比较低下。

2.2 同步代码块:

复制代码

    public static Singleton_2 getInstance() {
        synchronized (Singleton_2.class) {
            try {
                if (instance == null) {
                    // 模拟处理其他事情
                    Thread.sleep(3 * 1000);
                    instance = new Singleton_2();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return instance;
    }

复制代码

　　上面同步代码块相当于同步方法，所以效率还是低下。

2.3 使用DCL双检查锁机制(推荐这种)---需要结合volatile变量使用

复制代码

package cn.qlq.thread.fifteen;

/**
 * 延迟加载==饱汉模式
 * 
 * @author Administrator
 *
 */
public class Singleton_2 {

    private volatile static Singleton_2 instance;

    private Singleton_2() {
    }

    public static Singleton_2 getInstance() {
        try {
            if (instance == null) {
                synchronized (Singleton_2.class) {
                    // 模拟处理其他事情
                    Thread.sleep(3 * 1000);
                    if (instance == null) {
                        instance = new Singleton_2();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }
}

复制代码

　　DCL(Double check Lock)机制结合volatile是大多数多线程结合单例模式使用的场景。

 

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

　　使用静态内置类也可以实现单例模式。

复制代码

package cn.qlq.thread.fifteen;

/**
 * 静态内置类实现单例模式
 * 
 * @author Administrator
 *
 */
public class Singleton_3 {

    private static class Singleton_3Handle {
        private static final Singleton_3 instance = new Singleton_3();
    }

    private Singleton_3() {
    }

    public static Singleton_3 getInstance() {
        return Singleton_3Handle.instance;
    }
}

复制代码

 

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

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

复制代码

package cn.qlq.thread.fifteen;

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 java.io.Serializable;

/**
 * 静态内置类实现单例模式
 * 
 * @author Administrator
 *
 */
public class Singleton_4 implements Serializable {

    /**
     * serialize id
     */
    private static final long serialVersionUID = 4079299493423471357L;

    private static class Singleton_4Handle {
        private static final Singleton_4 instance = new Singleton_4();
    }

    private Singleton_4() {
    }

    public static Singleton_4 getInstance() {
        return Singleton_4Handle.instance;
    }

    /*protected Object readResolve() {
        System.out.println("调用readResolve方法");
        return Singleton_4Handle.instance;
    }*/

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        Singleton_4 instance = Singleton_4.getInstance();

        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(new File("tt.txt")));
        outputStream.writeObject(instance);
        outputStream.flush();
        outputStream.close();
        System.out.println(instance.hashCode());

        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(new File("tt.txt")));
        Singleton_4 readObject = (Singleton_4) inputStream.readObject();// 会自动调用readResolve
        inputStream.close();
        System.out.println(readObject.hashCode());
    }
}

复制代码

结果:

1221073180
1940009821

 

解决办法:将上面readResolve方法的注释去掉:（在inputStream.readObject时候会自动调用readResolve方法）

结果：

1221073180
调用readResolve方法
1221073180

 

5. static静态代码块实现单例模式

复制代码

package cn.qlq.thread.fifteen;

/**
 * 静态代码块实现单例模式
 * 
 * @author Administrator
 *
 */
public class Singleton_5 {

    private static Singleton_5 instance = null;

    private Singleton_5() {

    }

    static {
        instance = new Singleton_5();
    }

    public static Singleton_5 getInstance() {
        return instance;
    }

}

复制代码

 

6.使用枚举实现单例模式

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

复制代码

package cn.qlq.thread.fifteen;

/**
 * 枚举实现单例模式
 * 
 * @author Administrator
 *
 */
public enum Singleton_6 {

    instance;

    private Singleton_6() {
        System.out.println("调用构造方法");
    }

    public Singleton_6 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(Singleton_6.instance.getInstance());
    }
}

复制代码

结果：

调用构造方法
instance

 

补充:这里反汇编查看枚举类的代码发现其继承自Enum类，并且静态代码块中初始化实例

复制代码

$ javap -c Singleton_6.class
Compiled from "Singleton_6.java"
public final class Singleton_6 extends java.lang.Enum<Singleton_6> {
  public static final Singleton_6 instance;

  public static Singleton_6[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[LSingleton_6;
       3: invokevirtual #2                  // Method "[LSingleton_6;".clone:()L                                                                                                                java/lang/Object;
       6: checkcast     #3                  // class "[LSingleton_6;"
       9: areturn

  public static Singleton_6 valueOf(java.lang.String);
    Code:
       0: ldc_w         #4                  // class Singleton_6
       3: aload_0
       4: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Lj                                                                                                                ava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       7: checkcast     #4                  // class Singleton_6
      10: areturn

  public Singleton_6 getInstance();
    Code:
       0: getstatic     #10                 // Field instance:LSingleton_6;
       3: areturn

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #7                  // Field java/lang/System.out:Ljava/                                                                                                                io/PrintStream;
       3: getstatic     #10                 // Field instance:LSingleton_6;
       6: invokevirtual #11                 // Method getInstance:()LSingleton_6                                                                                                                ;
       9: invokevirtual #12                 // Method java/io/PrintStream.printl                                                                                                                n:(Ljava/lang/Object;)V
      12: return

  static {};
    Code:
       0: new           #4                  // class Singleton_6
       3: dup
       4: ldc           #13                 // String instance
       6: iconst_0
       7: invokespecial #14                 // Method "<init>":(Ljava/lang/Strin                                                                                                                g;I)V
      10: putstatic     #10                 // Field instance:LSingleton_6;
      13: iconst_1
      14: anewarray     #4                  // class Singleton_6
      17: dup
      18: iconst_0
      19: getstatic     #10                 // Field instance:LSingleton_6;
      22: aastore
      23: putstatic     #1                  // Field $VALUES:[LSingleton_6;
      26: return
}

复制代码

 

 

上面暴露了枚举类，违反了单一职责原则。解决办法如下:(枚举类作为静态内部类)

复制代码

package cn.qlq.thread.fifteen;

/**
 * 枚举实现单例模式
 * 
 * @author Administrator
 *
 */
public class Singleton_7 {
    public enum Singleton_7Handle {

        instance;

        private Singleton_7 singleton_7;

        private Singleton_7Handle() {
            singleton_7 = new Singleton_7();
            System.out.println("调用构造方法");
        }

        public Singleton_7 getSingleton_7() {
            return singleton_7;
        }

        public Singleton_7 getInstance() {
            return instance.getSingleton_7();
        }
    }

    public static void main(String[] args) {
        System.out.println(Singleton_7Handle.instance.getInstance());
    }

}

复制代码

结果:

调用构造方法
cn.qlq.thread.fifteen.Singleton_7@4eb09321

 

补充:其实运用反射可以破坏单例模式，创建多个实例，例如:

复制代码

package cn.qlq.thread.fifteen;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 静态代码块实现单例模式
 * 
 * @author Administrator
 *
 */
public class Singleton_8 {

    private static Singleton_8 instance = null;

    private Singleton_8() {

    }

    static {
        instance = new Singleton_8();
    }

    public static Singleton_8 getInstance() {
        return instance;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(Singleton_8.getInstance().hashCode());
        Class clazz = Singleton_8.class;
        Constructor declaredConstructor = clazz.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Singleton_8 newInstance = (Singleton_8) declaredConstructor.newInstance();
        Singleton_8 newInstance2 = (Singleton_8) declaredConstructor.newInstance();
        System.out.println(newInstance.hashCode());
        System.out.println(newInstance2.hashCode());
    }
}

复制代码

结果:

817899724
397836821
1326857436

 

【当你用心写完每一篇博客之后,你会发现它比你用代码实现功能更有成就感!】

Java多线程案例之单例模式(懒汉，饿汉，枚举)
未见花闻的博客
04-05 4034
本篇文章将介绍Java多线程中的几个典型案例之单例模式，所谓单例模式，就是一个类只有一个实例对象，本文将着重介绍在多线程的背景下，单例模式的简单实现。
Java多线程：单例模式
子夜的个人博客
02-10 1087
单例模式
JAVA 单例模式与多线程
liuqzan的博客
09-14 202
单例模式单例模式是一种常见的设计模式， 单例模式分三种：懒汉式单例、饿汉式单例、内部类单例、登记式单例几种。 单例模式有一下特点： 1、单例类只能有一个实例。 2、单例类必须自己自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 懒汉模式不是线程安全的。 饿汉模式是线程安全的。 内部内模式利用Classloader的特 注册表模式是线程安全的同时又提供运行期指定...
Java多线程单例模式
qq_40477092的博客
07-06 238
前言 这篇文章主要讲述基于Java语言实现多线程的单例模式。 单例模式的概述 为什么需要单例模式    对于一个软件系统中的某些类而言，只有一个实例很重要，例如一个系统只能有一个窗口管理器或文件系统，一个系统只能有一个集市工具或ID生成器等等。在Windows操作系统中就只能打开一个任务管理器窗口，如下图1所示。如果不使用机智对窗口对象进行唯一化，势必会弹出多个窗口。如果这些窗口显示的内容完全一致...
java多线程单例_Java多线程单例模式
weixin_33168937的博客
02-15 308
单例对象(Singleton)是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。正是由于这个特点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。对于一个软件系统中的某些类而言，只有一个实例很重要，例如一个系统只能有一个窗口管理器或文件系统，一个系统只能有一个集市工具或ID生成器等等。本文就和大家一起探讨一下在多线程环境下...
JAVA多线程中的单例模式
最新发布
weixin_65528013的博客
03-20 728
在 Java 里，单例模式指的是一个类仅有一个实例，并且提供一个全局访问点（公有get方法）来获取该实例。在多线程环境下实现单例模式时，需要保证线程安全，避免多个线程同时创建多个实例。下面介绍几种常见的多线程单例模式实现方式。
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
Java多线程下的单例模式参考
09-02
本篇将探讨如何在Java多线程下实现单例模式，重点关注`synchronized`关键字和`java.util.concurrent.locks.Lock`接口的`ReentrantLock`类。 首先，我们来看传统的懒汉式单例模式，它延迟初始化，只有在第一次调用`...
java多线程之线程安全的单例模式
09-02
在多线程环境下，线程安全的单例模式尤其重要，因为如果不正确地实现，可能会导致多个线程创建多个实例，违反了单例模式的基本原则。本文将详细介绍Java中线程安全的单例模式，包括懒汉式和饿汉式两种实现方式。 1....
Java 多线程之单例模式
抛弃幻想，准备斗争
03-25 518
DCL可以解决多线程单例模式的非线程安全问题。 运行结果： 序列化与反序列化实现的单例模式的实现 静态内置类可以达到线程安全问题，但如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。 使用static代码块实现单例模式 ...
Java多线程（七）：单例模式详解
澄白易的博客
04-27 2281
目录 1. 什么是单例模式 2. 单例模式的特点 3. 单例模式的实现 3.1 单例模式实现步骤 3.2 单例模式实现方式 3.2.1 饿汉方式 3.2.2 懒汉方式 1. 什么是单例模式 java中单例模式是一种常见的设计模式，单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个...
java 多线程 单例模式
sinat_41132860的博客
11-25 1272
单例模式: 单例模式是指在程序运行过程中,某个类在内存中只有一个对象,即让一个类只能创建一个对象,所以单例模式不能用new关键字创建 单例模式一般分为两种情况,饿汉式和懒汉式 创建单例模式的步骤: 1构造方法私有化private,保证外部访问不到构造方法,否则可以创建无限多个对象,私有化构造方法后系统不再提供默认的构造方法 2创建私有的private静态的static  当前对象类对象(...
java 线程 单例模式_JAVA_多线程_单例模式
weixin_39949889的博客
02-12 126
这篇是入职之后的第二篇了，上一篇我简单介绍了一下LOCK里面的类的方法，感兴趣的话可以去了解一下，以后坚持每周至少会更新一篇关于多线程方面的文章，希望博友们可以一起加油成长。这篇主要的内容是单例模式在多线程环境下的设计，这篇算是比较重要的内容，我会进行文字和代码的共同说明来讲解记录1、立即加载(饿汉模式)说到标题，有人会说什么是立即加载呢？立即加载就是使用类的时候已经将对象创建完毕了，比如说直接n...
Java——单例模式、多线程
爱是与世界平行
08-24 942
单例模式 单例模式练习 单例模式的分类 懒汉式 懒汉式相关练习 饿汉式 饿汉式相关练习 线程安全 使用双重检测机制实现线程安全的懒汉式 使用静态内部类实现线程安全的单例模式 多线程 单例模式 单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被成为单例类的特殊类。通过单例模式可以保证系统中一个类职业一个实例而且该实例易于外界访问，从而方面对实例个数的控制并节约系统资源。 如果希望在系统中
线程安全的单例模式
qq_64421953的博客
03-27 1971
单例模式具体的实现方式，分为“饿汉”和“懒汉”两种。 饿汉模式：类加载的同时创建实例 //通过Singleton这个类来实现单例模式，保证Singleton这个类只是唯一实例 //饿汉模式 class Singleton{ //1.使用static创建一个实例，并且立即进行实例化 // 这个instance对应的实例，就是该类的唯一实例 private static Singleton instance = new Singleton(); //2.为了防止程序员在
java 多线程的单例模式_Java多线程中的单例模式两种实现方式
weixin_29001419的博客
02-21 273
java多线程中的单例模式一、在多线程环境下创建单例方式一：package com.ietree.multithread.sync;public class singletion {private static class innersingletion {private static singletion single = new singletion();}public static sing...
Java多线程---单例模式(有趣易懂版)
Coder is on Mars的博客
03-20 8856
啊喂？单例模式尼？
java 单例 线程_Java - 单例模式与多线程
weixin_26933735的博客
02-22 255
标签：单例模式大家并不陌生，分为饿汉式和懒汉式等。线程安全的饿汉式单例饿汉式单例在类第一次加载的时候就完成了初始化，上代码：public classMyObject {private static MyObject myObject = newMyObject();public staticMyObject getInstance(){returnmyObject;}}下面来验证饿汉式单例的线程安...
java多线程 —— 单例模式
向来缘浅，奈何情深
03-19 1840
1、什么是单例？ 单例模式实际上是一种模式。它达到的效果是，在程序的运行过程中，一个类最多只会被实例化（初始化）一次。 2、为什么使用单例？ 上面我们已经知道单例模式，其实就是一个类的变量和方法最多只会被初始化一次，即全局唯一。全局唯一可以节省内存开销，提供全局唯一的变量和方法等等优点，但是其实静态变量和静态方法也是能达到全局唯一的效果，那么为什么一定要用单例呢？ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值