Day04j 单例模式的介绍

最新推荐文章于 2025-11-23 13:46:09 发布

原创最新推荐文章于 2025-11-23 13:46:09 发布 · 362 阅读

0 ·

CC 4.0 BY-SA版权

java Se 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java中的单例模式，包括其设计目的、特点以及常见的五种实现方式：懒汉式（线程不安全）、饿汉式、双重检查、静态内部类式和静态代码块实现。每种方式都结合了示例代码进行说明，强调了线程安全和延迟加载的重要性。

1.简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

单利模式是java中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

2.构建方式

通常单例模式在Java语言中，有两种构建方式：

懒汉方式。指全局的单例实例在第一次被使用时构建。
饿汉方式。指全局的单例实例在类装载时构建。

2.1单例模式有以下特点

显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

从具体实现角度来说，就是以下三点：一是单例模式的类只提供私有的构造函数，二是类定义中含有一个该类的静态私有对象，三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

2.2 单例模式的实现方式

单例模式的实现有多种方式

1.懒汉式线程不安全

package runoob.com;

/**
* @author zsj
*
*/
/*java 单利模式
* 单利模式只能有一个实例，他必须是自己创建这个实例，，他必须向整个系统提供这个实例
* 所以：创建的时候，具体来说，就是提供一个私有的构造函数，类定义中含有一个该类
* 的静态的私有对象，且该类提供了一个静态的公共方法用于创建或获取它本身的私有对象
* 1.懒汉式线程不安全
* ：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，
* 所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，
* 在多线程不能正常工作。*/
public class Singgleton {
   /*私有的构造方法*/
   private Singgleton() {};
   /*静态的私有对象*/
   private static Singgleton singgleton=null;
   /*静态的公共方法*/
   public static Singgleton getSinggleton() {
       /*这个判断是一定要加上的*/
       if(singgleton==null) {
           return new Singgleton();
       }
       return singgleton;
   }
   public void show() {
       System.out.println("饿汉式单利线程不安全");
   }
}

2.懒汉式线程安全

package runoob.com;

/**
* @author zsj
*
*/
/*java单利模式：
* 懒汉式，线程全
* */
public class Singgleton2 {

   private Singgleton2() {};
   private static Singgleton2 singgleton2=null;

//   public static synchronized Singgleton2 getSinggleton2() {
//
//       if(singgleton2==null) {
//           singgleton2=new Singgleton2();
//       }
//       return singgleton2;
//   }
   /*还有一种写法，与上面的写法是等同的：如下*/

   /*在方法上加synchronized同步锁或是用同步代码块对类加同步锁，此种方式虽然解决了多个实例对象问题，
   * 但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，
   * 才可以继续运行。*/
   public static Singgleton2 getSinggleton2() {

       synchronized(Singgleton2.class) {
           if(singgleton2==null) {
               return singgleton2=new Singgleton2();
           }

       }
       return singgleton2;


   }
   public void show() {
       System.out.println("懒汉式线程安全");
   }

}

3.饿汉式

package runoob.com;

/**
* @author zsj
*
*/
/*单利模式实现方式
* 饿汉式 :饿汉式单例类.在类初始化时，已经自行实例化
* 这种方式比较常用
* 饿汉式单例在类加载初始化时就创建好一个静态的对象供外部使用，
* 除非系统重启，否则这个对象不会改变，所以本身就是线程安全的。*/
public class Singgleton3 {

   private Singgleton3(){};
   private static Singgleton3 singgleton3=new Singgleton3();
   // 静态工厂方法
   public static Singgleton3 getSinggleton3() {

       return singgleton3;
   }

   public void show() {
       System.out.println("饿汉式单利");
   }
}

4.双重检索

使用双重检查（相对于懒汉式线程安全）进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

package runoob.com;

/**
* @author zsj
*
*/
/*单利模式单利模式实现方式
* 1.双重检查
* 使用双重检查（相对于懒汉式线程安全）进一步做了优化，
* 可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。*/
public class Singgleton4 {

   private Singgleton4() {   }
   private static Singgleton4 singgleton4=null;

   public static Singgleton4 getSinggleton4() {

       if(singgleton4==null) {
       synchronized(Singgleton4.class) {
           if(singgleton4==null) {
               return new Singgleton4();
           }
       }
       }
       return singgleton4;
   }
   public void show() {
       System.out.println("单利模式双重检查");
   }
}

5.静态内部类式

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

package runoob.com;

/**
* @author zsj
*
*/
/*单利模式的方式：
* 静态内部类*/
public class Singgleton5 {

   //声明一个静态内部类
   private static class SinggletonClass{
       private final static Singgleton5 singgleton5=new Singgleton5();
   }
   public static Singgleton5 getSinggleton5() {

       return SinggletonClass.singgleton5;
   }
   public void show() {
       System.out.println("静态内部类式的单利模式");
   }
}

6.static静态代码块实现

package runoob.com;

/**
* @author zsj
*
*/
/*单利模式的实现方式
* 静态代码块方式*/
public class Singglet6 {

   private Singglet6() {};
   private static Singglet6 singglet6=null;

   static {
       singglet6=new Singglet6();
   }
   public static Singglet6 getSingglet() {
       return singglet6;
   }
   public void show() {
       System.out.println("静态代码块方式实现");
   }
}
一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式