单例模式

于 2021-05-23 17:04:26 发布
阅读量58 收藏
点赞数 1
分类专栏： java入门 文章标签： java 设计模式 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53979929/article/details/117197427
版权
01.饿汉式（静态常量）
02.饿汉式（静态代码块）
03.懒汉式（线程不安全）
04.懒汉式（线程安全，同步方法）
05.懒汉式（线程安全，同步代码块）
06.双重检查
07.静态内部类
08.枚举

01.饿汉式（静态常量）

package 单例模式;

public class HungrySingleton {
	 public static void main(String[] args) {
		    //测试
		        Singleton instance = Singleton.getInstance();
		        Singleton instance2 = Singleton.getInstance();
		        System.out.println(instance == instance2); // true
		        System.out.println("instance.hashCode=" + instance.hashCode());
		        System.out.println("instance2.hashCode=" + instance2.hashCode());
		    }
		}
		//饿汉式(静态变量)
		class Singleton {
		    //1. 构造器私有化,  外部不能 new 
		    private Singleton() {}

		    //2.本类内部创建对象实例
		    private final static Singleton instance = new Singleton();

		    //3. 提供一个公有的静态方法，返回实例对象
		    public static Singleton getInstance() {
		        return instance;
		    }

}

类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。

好处: 只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。

缺点:也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。

02.饿汉式（静态代码块）
package 单例模式;

public class HungrySingletonstatic {
	public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

//饿汉式(静态变量) 
class Singleton {
    //1. 构造器私有化,  外部不能 new 
    private Singleton() {}

    //2.本类内部创建对象实例
    private static Singleton instance;

    static { // 在静态代码块中，创建单例对象（类装载的时候执行）
        instance = new Singleton();
    }

    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
 
}

03.懒汉式（线程不安全）

package 单例模式;

public class LazySingletonsafe {
	 public static void main(String[] args) {
	        System.out.println("懒汉式 1 ， 线程不安全~");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2); // true
	        System.out.println("instance.hashCode=" + instance.hashCode());
	        System.out.println("instance2.hashCode=" + instance2.hashCode());
	    }

	}
 
	class Singleton {

	    private static Singleton instance;

	    private Singleton() {}

	    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
	    //即 懒汉式
	    public static Singleton getInstance() {
	        if(instance == null) {
	            instance = new Singleton();
	        }
	        return instance;
	    }
 
}

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。

适用场景：如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。

缺点：但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，实现如下。

04.懒汉式（线程安全，同步方法）

 package 单例模式;

public class LazySingletonsafetogether {
	public static void main(String[] args) {
        System.out.println("懒汉式 2 ， 线程安全~");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}
 
// 懒汉式(线程安全，同步方法)
class Singleton {
    private static Singleton instance;

    private Singleton() {}

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
 
}

05.懒汉式（线程安全，同步代码块）

class Singleton {
    private static Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {
        if(singleton == null) {
            synchronized(Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

06.双重检查

 package 单例模式;

public class shuangchongjiancha {
    public static void main(String[] args) {
        System.out.println("双重检查");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

// 懒汉式（线程安全，同步方法）
class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static Singleton getInstance() {
        //第一次检查，可以保证在对象创建好之后，每个线程在想获得类的实例不需要再进行同步
        //解决了“懒汉式(线程安全，同步方法)”的缺点
        if(instance == null) {
            synchronized (Singleton.class) {
                //第二次检查，可以避免当多个线程挤进此语句时，创建多个实例
                //解决了“懒汉式(线程不安全)”的缺点
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。因此就有了双重校验锁 。

07.静态内部类

package 单例模式;
public class jingtaileibu {
public static void main(String[] args) {
        System.out.println("使用静态内部类完成单例模式");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true 
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

// 静态内部类完成，推荐使用
class Singleton {
    private static volatile Singleton instance;

    //构造器私有化
    private Singleton() {}

    //写一个静态内部类,该类中有一个静态属性 Singleton 
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这种方式同样利用了类加载机制来保证只创建一个instance实例。

它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。

不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。

也就是说这种方式可以同时保证延迟加载和线程安全。

08.枚举

package 单例模式;
public class meiju {
public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        instance.sayOK();
    }
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
    INSTANCE; //属性
    public void sayOK() {
        System.out.println("ok~");
    }
}

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

哒达达达不溜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单例设计模式
qq_59708493的博客
05-19 1230
1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 2.单例设计模式有两种方式：1）饿汉式。2）懒汉式 2.单例设计模式的应用实例 1.步骤 1）构造器私有化=》防止用户直接new出一个对象 2）类的内部创建对象 3）向外暴露一个静态的公共方法。 4）代码实现 2.单例模式-饿汉式 package com.demo.single_; public class test01 { pub
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
1：单例设计模式
qq_35649064的博客
10-19 234
今天算是从公司实习回来现场面试的第一家公司，一共三轮技术一轮HR面试体验很好！加了一面面试官的微信！感谢每一个面试官！！！！！ 总结下面试的知识点和自己不足的地方！喜欢做开发。那就继续做下去吧！ ...
单例模式介绍
12-15
单例模式是软件设计模式中的一种，用于控制类的实例化过程，确保一个类在整个程序运行期间只有一个实例存在。在Android开发中，单例模式应用广泛，尤其在管理全局资源、提供公共服务或优化性能时非常实用。下面我们...
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
Java单例模式简单示例
08-30
Java单例模式简单示例 Java单例模式是一种非常常用的设计模式，它可以确保某个类只有一个实例，并提供一个全局访问点。下面我们将通过一个简单的示例来介绍Java单例模式的定义和使用技巧。 单例模式的定义 单例...
7种单例模式
11-21
单例模式是软件设计模式中的一种经典模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下非常有用，比如控制共享资源、管理配置对象等。下面将详细介绍七种常见的单例模式实现...
C++中的单例模式
Mars 尘的专栏
01-19 417
如果采用全局或者静态变量的方式，会影响封装性，难以保证别的代码不会对全局变量造成影响。 1.懒汉式是以时间换空间的方式。 2.饿汉式是以空间换时间的方式。 懒汉式 懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。。。。。。 ? 1 2 3
单例模式与工厂模式解析
"单例模式与工厂模式是两种常见的设计模式，在软件开发中有着广泛的应用。单例模式确保一个类只有一个实例，而工厂模式则允许子类决定实例化哪个类。这两种模式各有特点，适用于不同的场景。" 1. **单例模式**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值