单例模式的多种实现

最新推荐文章于 2023-04-22 22:00:04 发布
最新推荐文章于 2023-04-22 22:00:04 发布
阅读量86 收藏
点赞数
分类专栏： java 单例模式 设计模式 文章标签： java 设计模式 单例模式 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40244614/article/details/96912305
版权

单例模式的详情请关注《陈词滥调的单例》

#饿汉式（立即加载）

package com.zuoyang.singleton;

/**
 * 饿汉式：
 *  * 线程安全，在线程还出现以前就是创建了对象
 *
 */
public class SingLetonHungry  {
    private static  SingLetonHungry singLetonHungry = new SingLetonHungry();
   private SingLetonHungry(){}
   public static SingLetonHungry getInstance(){
       return singLetonHungry;
   }
}

###线程类

package com.zuoyang.singleton;

public class SingLetonHungryThread extends Thread {
    @Override
    public void run(){
 //        通过打印类的hashCode来确定是否为一个对象
        System.out.println(SingLetonHungry.getInstance().hashCode());
    }
}

###运行类

package com.zuoyang.singleton;

public class SingLetonHungryRun {
    public static void main(String[] args) {
        SingLetonHungryThread singLetonHungryThread1 = new SingLetonHungryThread();
        SingLetonHungryThread singLetonHungryThread2 = new SingLetonHungryThread();
        SingLetonHungryThread singLetonHungryThread3 = new SingLetonHungryThread();
        singLetonHungryThread1.start();
        singLetonHungryThread2.start();
        singLetonHungryThread3.start();
    }
}

###运行结果
[外链图片转存失败(img-xaLy3mdv-1563808031426)( https://uploader.shimo.im/f/UtBoMWPlgToCtr3n.png)]
#懒汉式（延迟加载）

##线程不安全版

package com.zuoyang.singleton;

/**
 *  懒汉式单例，但是多线程的情况下不安全
 */
public class SinLetonLazyOne {
    //静态块，公共内存区域
    private static SinLetonLazyOne sinLetonLazyOne;

    private SinLetonLazyOne(){
    }
    //调用方法之前，先判断
    //如果没有初始化，将其进行初始化,并且赋值
    //将该实例缓存好
    public static SinLetonLazyOne getInstance(){
        if (sinLetonLazyOne!=null) {

        }else {
            //两个线程都会进入这个if里面
             sinLetonLazyOne = new SinLetonLazyOne();
        }
        //如果已经初始化，直接返回之前已经保存好的结果
        return sinLetonLazyOne;
    }
}

###线程类

package com.zuoyang.singleton;

public class SinLetonlLazyOneThread extends Thread {

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

###运行类

package com.zuoyang.singleton;

public class SinLetonlLazyOneRun {
    public static void main(String[] args) {
        SinLetonlLazyOneThread sinLetonlLazyOneThread1 = new SinLetonlLazyOneThread();
        SinLetonlLazyOneThread sinLetonlLazyOneThread2 = new SinLetonlLazyOneThread();
        SinLetonlLazyOneThread sinLetonlLazyOneThread3 = new SinLetonlLazyOneThread();
        sinLetonlLazyOneThread1.start();
        sinLetonlLazyOneThread2.start();
        sinLetonlLazyOneThread3.start();
    }
}

###运行结果

##synchronized关键字版

package com.zuoyang.singleton;

/**
 * 基于加锁的线程安全的懒汉式单例
 */
public class SinLetonLazyTwo {

    private static SinLetonLazyTwo sinLetonLazyTwo;

    private SinLetonLazyTwo() {
    }

    //加锁 来保证多线程的情况下也是一个单例
    synchronized public static SinLetonLazyTwo getInstance() {
        try {
            if (sinLetonLazyTwo != null) {
            } else {
                Thread.sleep(3000);
                sinLetonLazyTwo = new SinLetonLazyTwo();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sinLetonLazyTwo;
    }
}

###线程类

package com.zuoyang.singleton;

public class SinLetonlLazyTwoThread extends Thread {

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

###运行类

package com.zuoyang.singleton;

public class SinLetonlLazyTwoRun {
    public static void main(String[] args) {
        SinLetonlLazyTwoThread sinLetonlLazyTwoThread1 = new SinLetonlLazyTwoThread();
        SinLetonlLazyTwoThread sinLetonlLazyTwoThread2 = new SinLetonlLazyTwoThread();
        SinLetonlLazyTwoThread sinLetonlLazyTwoThread3 = new SinLetonlLazyTwoThread();
        sinLetonlLazyTwoThread1.start();
        sinLetonlLazyTwoThread2.start();
        sinLetonlLazyTwoThread3.start();
    }
}

###运行结果

###同步代码块版（线程不安全）

package com.zuoyang.singleton;

/**
 * 基于加锁的线程不安全的懒汉式单例
 */
public class SinLetonLazyTwoTwo {

    private static SinLetonLazyTwoTwo sinLetonLazyTwoOne;

    private SinLetonLazyTwoTwo() {
    }

    //加锁 来保证多线程的情况下也是一个单例

    public static SinLetonLazyTwoTwo getInstance() {
        try {

            if (sinLetonLazyTwoOne != null) {
            } else {
                Thread.sleep(3000);
                synchronized (SinLetonLazyTwoTwo.class) {
                    sinLetonLazyTwoOne = new SinLetonLazyTwoTwo();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sinLetonLazyTwoOne;
    }
}

###线程类

package com.zuoyang.singleton;

public class SinLetonlLazyTwoOneThread extends Thread {

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

###运行类

package com.zuoyang.singleton;

public class SinLetonlLazyTwoTwoRun {
    public static void main(String[] args) {
        SinLetonlLazyTwoTwoThread sinLetonlLazyTwoTwoThread1 = new SinLetonlLazyTwoTwoThread();
        SinLetonlLazyTwoTwoThread sinLetonlLazyTwoTwoThread2 = new SinLetonlLazyTwoTwoThread();
        SinLetonlLazyTwoTwoThread sinLetonlLazyTwoTwoThread3 = new SinLetonlLazyTwoTwoThread();
        sinLetonlLazyTwoTwoThread1.start();
        sinLetonlLazyTwoTwoThread2.start();
        sinLetonlLazyTwoTwoThread3.start();
    }
}

###运行结果

###DCL双检查锁机制版（Double-Check Locking）

package com.zuoyang.singleton;

/**
 * 基于双重检查锁的机制实现的单例模式
 */
public class SinLetonLazyThree {

    private static SinLetonLazyThree sinLetonLazyTwoOne;

    private SinLetonLazyThree() {
    }


    public static SinLetonLazyThree getInstance() {
        try {
//存在多个线程，跑进来在这里
            if (sinLetonLazyTwoOne != null) {
            } else {
                Thread.sleep(3000);
                //后面进来的线程需要判断lazy是否已经初始化了，不然的话，会重新创建新的对象
                synchronized (SinLetonLazyThree.class) {
                    if (sinLetonLazyTwoOne == null)
                        sinLetonLazyTwoOne = new SinLetonLazyThree();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return sinLetonLazyTwoOne;
    }
}

###线程类

package com.zuoyang.singleton;

public class SinLetonlLazyThreeThread extends Thread {

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

###运行类

package com.zuoyang.singleton;

public class SinLetonlLazyThreeRun {
    public static void main(String[] args) {
        SinLetonlLazyThreeThread sinLetonlLazyThreeThread1 = new SinLetonlLazyThreeThread();
        SinLetonlLazyThreeThread sinLetonlLazyThreeThread2 = new SinLetonlLazyThreeThread();
        SinLetonlLazyThreeThread sinLetonlLazyThreeThread3 = new SinLetonlLazyThreeThread();
        sinLetonlLazyThreeThread1.start();
        sinLetonlLazyThreeThread2.start();
        sinLetonlLazyThreeThread3.start();
    }
}

###运行结果

#使用静态内部类实现单例模式

package com.zuoyang.singleton;

public class SingLetonStatic {
    private static  SingLetonStatic singLetonStatic =null;

    private SingLetonStatic(){}

    static {
        singLetonStatic = new SingLetonStatic();
    }

    public static SingLetonStatic getInstance() {
        return singLetonStatic;
    }
}

###线程类

package com.zuoyang.singleton;

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

###运行类

package com.zuoyang.singleton;

public class SingLetonStaticRun {
    public static void main(String[] args) {
        SingLetonStaticThread singLetonStaticThread1 = new SingLetonStaticThread();
        SingLetonStaticThread singLetonStaticThread2 = new SingLetonStaticThread();
        SingLetonStaticThread singLetonStaticThread3 = new SingLetonStaticThread();
        singLetonStaticThread1.start();
        singLetonStaticThread2.start();
        singLetonStaticThread3.start();
    }
}

###运行结果

#序列化与反序列化的单例模式

package com.zuoyang.singleton;

import java.io.Serializable;

public class SingLetonSerializable implements Serializable {

    private SingLetonSerializable(){}

    private static class SingLetonSerializableHandler{
        private static final SingLetonSerializable singLetonSerializable  = new SingLetonSerializable();
    }

    public static SingLetonSerializable getInstance(){
        return SingLetonSerializableHandler.singLetonSerializable;
    }

    protected Object readResolve(){
        return SingLetonSerializableHandler.singLetonSerializable;
    }
}

###运行类

package com.zuoyang.singleton;

import java.io.*;

public class SingLetonSerializableSaveAndRead {
    public static void main(String[] args) {
        try {
            SingLetonSerializable singLetonSerializable = SingLetonSerializable.getInstance();
            FileOutputStream fileOutputStream = new FileOutputStream(new File("E://MyOne.txt"));
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(singLetonSerializable);
            objectOutputStream.close();
            fileOutputStream.close();
            System.out.println(singLetonSerializable.hashCode());
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }

        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(new File("E://MyOne.txt"));
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            SingLetonSerializable singLetonSerializable = (SingLetonSerializable)objectInputStream.readObject();
            objectInputStream.close();
            fileInputStream.close();
            System.out.println(singLetonSerializable.hashCode());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

###运行结果

#enum枚举实现单例模式

package com.zuoyang.singleton;

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

public class SingLetonEumOne {
    public enum SingLetonEumTest {
        connectionFactory;
        private Connection connection;
        private SingLetonEumTest(){
            try {
                Class.forName("com.mysql.jdbc.Driver");
                String url="jdbc:mysql://localhost:3306";
                String user="root";
                String password="root";
                connection = DriverManager.getConnection(url,user,password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        public Connection getConnection(){
            return connection;
        }
    }
    public static Connection getConnection(){
        return SingLetonEumTest.connectionFactory.getConnection();
    }
}

###线程类

package com.zuoyang.singleton;

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

    }
}

###运行类

package com.zuoyang.singleton;

public class SingLetonEumRunTest {
    public static void main(String[] args) {
        SingLetonEumThreadTest singLetonEumThreadTest1 = new SingLetonEumThreadTest();
        SingLetonEumThreadTest singLetonEumThreadTest2 = new SingLetonEumThreadTest();
        SingLetonEumThreadTest singLetonEumThreadTest3 = new SingLetonEumThreadTest();
        singLetonEumThreadTest1.start();
        singLetonEumThreadTest2.start();
        singLetonEumThreadTest3.start();
    }
}

###运行结果

#GitHub地址

https://github.com/dxf1998/singleton.git
左羊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python单例模式的多种实现方法
09-18
主要介绍了python单例模式的多种实现方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
单例模式详细总结（8种实现方式，看完就会）
qq_59957669的博客
01-10 1668
单例模式详细总结(看完你就会)
单例模式的N种实现方式
小黑说Java
12-27 1867
如果你自认为已经掌握懒汉式、饿汉式、DCL、IoDH、枚举等单例实现方式，可以直接看最后的打破单例。如果不是，建议你耐心从头看完。 相信你看完本文能让你掌握Java中所有单例模式的设计方式。 单例设计模式是GOF 23中设计模式中常见的设计模式之一，不论是在我们日常开发，还是一些第三方库中几乎都能见到单例模式。包括在面试时初中级的程序员基本都会被问到单.
单例模式（6种实现方式）
qq_31856061的博客
07-01 1055
定义： 确保一个类只有一个实例，并提供该实例的全局访问点。这样做的好处是：有些实例，全局只需要一个就够了，使用单例模式就可以避免一个全局使用的类，频繁的创建与销毁，耗费系统资源。一个私有构造函数 （确保只能单例类自己创建实例） 一个私有静态变量 （确保只有一个实例） 一个公有静态函数 （给使用者提供调用方法） 简单来说就是，单例类的构造方法不让其他人修改和使用；并且单例类自己只创建一个实例，这个实例，其他人也无法修改和直接使用；然后单例类提供一个调用方法，想用这个实例，只能调用。这样就确保了全局只创建了一次
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 3759
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
单例模式6种实现方式
热门推荐
飞少fly的博客
06-04 1万+
一：饿汉式public class MyObject { // 立即加载方式==饿汉模式 private static MyObject myObject = new MyObject(); private MyObject() { } public static MyObject getInstance() { // 此代码版本为立即加载 // 此版本代码的缺点是不能有其...
单例模式的多种实现.docx
06-09
单例模式的七种实现方法以及分析，可以作文大作业提交 1.前言 4 1.1 课题的研究背景 4 1.2 课题主要研究目标 4 2.相关技术简介 4 2.1Java简介 4 2.2IDEA简介 4 3. 单例模式的7种实现方式 5 3.1饿汉式（使用静态常量...
单例设计模式实现总结
12-22
单例模式的总体概述 单例模式，属于创建型模式，《设计模式》一书对它做了定义：保证一个类仅有一个实例，并提供一个全局访问点。 ...多种实现方式与比较 线程安全的饿汉模式 public class HungryS
单例模式代码实现
05-13
这个讲的是单例模式的多种不同实现方式,希望对单例感兴趣的同学看看
详解JAVA单例模式及多种实现.doc
最新发布
09-22
详解JAVA单例模式及多种实现
设计模式【单例模式】（5种方法实现）
m0_57258620的博客
09-16 1171
对于单例模式，如果平常没有明确需求的就可以使用饿汉式，如果要明确需求懒加载，就可以用静态内部类的方法，如果有另外的需求，试一试双检锁方式，枚举法是比较值得尝试的（写一下，防丢）
java：单例模式的五种实现方式
weixin_42602900的博客
04-24 1万+
目录 1. 概述 2. 优缺点 3. 单例模式实现方式 3.1 饿汉式 3.2 懒汉式 3.3 double-checked locking（双重检查锁） 3.4 静态内部类 3.5 枚举 1. 概述 java单例模式是一种常见的设计模式。 单例模式有以下特点： 单例类只能有一个实例； 单例类必须自己创建自己的唯一实例； 单例类必须给所有其他对象提供这一实例； 2. 优缺点 优点：由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统运行效率。 缺点：因为系统中只有一个实例，导致了单
7种单例模式实现
qq_63815371的博客
12-05 404
目录单例模式介绍0. 静态类使用1. 懒汉模式(线程不安全)2. 懒汉模式(线程安全)3. 饿汉模式(线程安全)4. 使用类的内部类(线程安全) 推荐5. 双重锁校验(线程安全)6. CAS「AtomicReference」(线程安全)7. Effective Java作者推荐的枚举单例(线程安全)总结 单例模式可以说是整个设计中最简单的模式之一，而且这种方式即使在没有看设计模式相关资料也会常用在编码开发中。因为在编程开发中经常会遇到这样一种场景，那就是需要保证一个类只有一个实例哪怕多线程同时访问，并需要提
单例模式的简单实现
acoolper的专栏
07-18 1121
为什么上述懒汉式单例是线程不安全的呢，如下代码，在Lazy类的无参构造中加入一行打印并引入多线程场景进行测试。在类的一个生命周期中静态代码块只在类加载时执行一次，可以满足单例模式的设计要求(此处暂不考虑。类型是Java5中新增特性的一部分，也是类（class）的一种，自带单例模式，且可以防止。概念23种设计模式之一，通过单例模式的方法创建的类在整个应用程序中只有一个实例。无论该对象是否被使用，在类加载的时候都会被创建，一定程度上导致内存资源的浪费。类加载的时候就创建该类的唯一实例对象，...
单例模式的实现
code_ang的博客
05-21 2692
一、什么是单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 需要注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 实现说明： 1、私有化该类的构造方法，构造方法私有化，其
单例模式的五种实现方式
qq_43626599的博客
12-24 1384
单例模式的五种实现方式
单例模式的几种实现方式
不会飞的鱼的博客
03-12 4716
文章目录一、懒汉式单例模式线程安全的懒汉式单例模式二、双重检测锁实现单例模式三、饿汉式单例模式四、静态内部类实现单例模式五、枚举实现单例模式 一、懒汉式单例模式 懒汉式单例模式，即是在需要用到该对象的时候才去进行初始化，代码如下： public class Singleton { private static final Singleton instance; private Singleton () {} public static Singleton getInstance(
单例模式的6种实现方式
weixin_45683240的博客
05-20 1248
单例模式的6种实现方式 一、单例模式的定义 **定义：**确保一个类只有一个实例，并提供该实例的全局访问点。 这样做的好处是：有些实例，全局只需要一个就够了，适用单例模式就可以避免一个全局适用的类，频繁的创建和销毁，耗费系统资源。 二、单例模式的设计要素 一个私有构造函数(确保只能单例类自己创建实例) 一个私有静态变量(确保只有一个实例) 一个公有静态函数(给使用者提供调用方法) 简单来说就是，单例类的构造方法不让其他人修改和适用；并且单例类自己只创建了一个实例，这个实例，其他人也无法修改和直接适用；然后单
单例模式的几种实现
zhangxiaowei
06-15 2733
单例模式的几种实现
单例模式的设计与实现要点
06-10
单例模式的实现方式有多种，例如饿汉式、懒汉式、双重检查锁等。选择哪种实现方式取决于具体的应用场景和需求。需要注意的是，单例模式虽然有很多优点，但也有一些缺点，例如可能导致代码的复杂性增加、单例对象的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值