单例设计模式

单例设计模式

• Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

• 单例设计模式的两种方法

  • 饿汉式

    1. 构造器私有化（防止在外部直接new）

    2. 类的内部创建对象

    3. 向外暴露一个静态的公共方法

    4. 代码实现

       package com.oop.Singleton;
       
       /**
        * @author ybl 1240801282@qq.com
        * @version 1.0
        */
       public class Singleton01 {
       
           public static void main(String[] args) {
       
               //可以直接通过方法可以获取对象
               GirlFriend instance = GirlFriend.getInstance();
       
               System.out.println(instance);
           }
       }
       
       /*
       单例设计模式：一个类有且仅有一个实例，并且自行实例化向整个系统提供。
       例：有一个类，GirlFriend 只能有一个女朋友
       饿汉式
        */
       class GirlFriend{
       
           private String name;
       
           //2、在类的内部直接创建对象
           // 为了能够在静态方法中，返回gf对象，需将其修饰为static
           private static GirlFriend gf = new GirlFriend("小红红");
       
           //1.将构造器私有化
           private GirlFriend(String name) {
               this.name = name;
           }
       
           //3、向外暴露一个静态的公共方法
           public static GirlFriend getInstance(){
               return gf;
           }
       
           @Override
           public String toString() {
               return "GirlFriend{" +
                       "name='" + name + '\'' +
                       '}';
           }
       }
       
       

  • 懒汉式

    1. 构造器私有化

    2. 定义一个static静态对象

    3. 提供一个public的static的方法，可以返回Cat对象

    4. package com.oop.Singleton;
       
       /**
        * @author ybl 1240801282@qq.com
        * @version 1.0
        */
       public class Singleton02 {
       }
       /*
       懒汉式
        */
       class Cat{
           private String name;
       
           //2、定义一个static静态对象
           private static Cat cat;
       
           //1、构造器私有化
           private Cat(String name) {
               this.name = name;
           }
       
           //3、提供一个public的static的方法，可以返回Cat对象
           public static Cat getInstance() {
               if (cat == null){
                   cat = new Cat("Tom");
               }
               return cat;
           }
       
           @Override
           public String toString() {
               return "Cat{" +
                       "name='" + name + '\'' +
                       '}';
           }
       
       }
       

  • 饿汉式VS懒汉式

    1. 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
    2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。
    3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
    4. 在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式。

  • 饿汉式与懒汉式的区别

    • 懒汉式—线程不安全：最基础的实现方式，线程上下文单例，不需要共享给所有线程，也不需要加synchronize之类的锁，以提高性能。
    • 懒汉式—线程安全：加上synchronize之类保证线程安全的基础上的懒汉模式，相对性能很低，大部分时间并不需要同步
    • 饿汉方式。指全局的单例实例在类装载时构建。 [2]
    • 双检锁式。在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建时没有线程间竞争而产生多个实例，仅第一次创建时同步，性能相对较高
    • 登记式。作为创建类的全局属性存在，创建类被装载时创建
    • 枚举。java中枚举类本身也是一种单例模式