欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

创建型设计模式--单例模式

程序员文章站 2023-04-05 14:04:35
一、单例模式 1、什么是单例模式 采取一定的方法,使程序中的某个类只存在一个实例对象,且该类对外提供一个获取该对象的方法(一般为静态方法)。 2、单例模式分类 (1)饿汉式(2种写法,线程安全) 静态变量 静态代码块 (2)懒汉式(3种写法) 线程不安全 线程安全,同步方法 线程安全,同步代码块(不 ......

一、单例模式

1、什么是单例模式

  采取一定的方法,使程序中的某个类只存在一个实例对象,且该类对外提供一个获取该对象的方法(一般为静态方法)。

2、单例模式分类

(1)饿汉式(2种写法,线程安全)
  静态变量
  静态代码块

(2)懒汉式(3种写法)
  线程不安全
  线程安全,同步方法
  线程安全,同步代码块(不推荐使用)

(3)双重检查(推荐使用)
(4)静态内部类(推荐使用)
(5)枚举(推荐使用)

3、饿汉式单例模式(静态常量版)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部创建实例对象。
  step3:向外暴露一个静态的公共方法用于获取实例对象。
(2)代码实现:

package singleton.pattern.demo1;

/**
 * 演示 饿汉式单例模式,静态变量版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 饿汉式单例模式,静态变量版
 */
class singleton {
    // 在类的内部创建实例对象。使用静态变量,只被加载一次。
    private static singleton singleton = new singleton();

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        return singleton;
    }
}

(3)优缺点:
  优点:写法简单,在类装载时完成了实例化,避免线程同步问题。
  缺点:在类装载前完成实例化,没有实现懒加载(lazy loading),可能造成内存的浪费(比如从不使用该类时会造成内存的浪费)。

(4)uml图:

创建型设计模式--单例模式

 

4、饿汉式单例模式(静态代码块)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部声明实例对象,并在静态代码块中实例化对象。
  step3:向外暴露一个静态的公共方法用于获取实例对象。
(2)代码实现:

package singleton.pattern.demo2;

/**
 * 演示 饿汉式单例模式,静态代码块版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 饿汉式单例模式,静态代码块版
 */
class singleton {
    // 在类的内部声明一个实例对象
    private static singleton singleton;

    static {
        // 在代码块中实例化一个对象,同样只加载一次
        singleton = new singleton();
    }

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        return singleton;
    }
}

(3)优缺点同上例 饿汉式单例模式(静态常量版)

5、懒汉式单例模式(线程不安全)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部声明实例对象。
  step3:向外暴露一个静态的公共方法用于获取实例对象,在调用该方法时,才去创建实例对象。
(2)代码实现:

package singleton.pattern.demo3;

/**
 * 演示 懒汉式单例模式,线程不安全版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 懒汉式单例模式,线程不安全版
 */
class singleton {
    // 在类的内部声明一个实例对象
    private static singleton singleton;

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象。 当调用该方法时,才去检查并创建一个实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        if (singleton == null) {
            singleton = new singleton();
        }
        return singleton;
    }
}

(3)优缺点:
  优点:实现了懒加载。
  缺点:只能在单线程下使用,比如线程a与线程b并发执行到 if (singleton == null), 此时便会产生多个实例对象。

6、懒汉式单例模式(线程安全,同步方法)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部声明实例对象。
  step3:向外暴露一个静态的公共方法(给静态方法加个synchronized关键字,解决同步问题)用于获取实例对象,在调用该方法时,才去创建实例对象。
(2)代码实现:

package singleton.pattern.demo4;

/**
 * 演示 懒汉式单例模式,线程安全,同步方法版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 懒汉式单例模式,线程安全,同步方法版
 */
class singleton {
    // 在类的内部声明一个实例对象
    private static singleton singleton;

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象,并给方法加个synchronized关键字,解决同步的问题。
     * 当调用该方法时,才去检查并创建一个实例对象。
     * 
     * @return 实例对象
     */
    public static synchronized singleton getsingleton() {
        if (singleton == null) {
            singleton = new singleton();
        }
        return singleton;
    }
}

(3)优缺点:
  优点:实现了懒加载,解决了线程不安全的问题。
  缺点:效率太低,每个线程想获取实例对象时,均会触发同步方法,此时会等待前一个线程调用结束后才能使用,使效率低。

 

7、懒汉式单例模式(同步代码块方法,线程不一定安全)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部声明实例对象。
  step3:向外暴露一个静态的公共方法(在静态方法内部定义一个代码块,解决同步问题)用于获取实例对象,在调用该方法时,才去创建实例对象。
(2)代码实现:

package singleton.pattern.demo5;

/**
 * 演示 懒汉式单例模式,线程不一定安全,同步代码块版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 懒汉式单例模式,线程不一定安全,同步代码块版
 */
class singleton {
    // 在类的内部声明一个实例对象
    private static singleton singleton;

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象,在方法内部加个同步代码块。 当调用该方法时,才去检查并创建一个实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        if (singleton == null) {
            synchronized (singleton.class) {
                singleton = new singleton();
            }
        }
        return singleton;
    }
}

(3)优缺点:
  优点:优化了了上例 懒汉式单例模式(线程安全,同步方法) 的效率问题。
  缺点:能满足大部分线程安全的情况,但是若线程a与线程b并发执行到 if (singleton == null),此时同步代码块的作用就不存在了, 会产生多个实例对象。

 

8、双重检查(double check)

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部声明实例对象,并使用volatile关键字(保证可见性,且防止因jvm指令重排使代码执行顺序不对,从而导致代码执行有误)。
  step3:向外暴露一个静态的公共方法(在静态方法内部定义一个代码块,解决同步问题)用于获取实例对象,在调用该方法时,才去创建实例对象。在上例 懒汉式单例模式(同步代码块方法,线程不一定安全) 的基础上,给同步代码块内部加个检查处理。
(2)代码实现:

package singleton.pattern.demo6;

/**
 * 演示 单例模式,双重检查版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 单例模式,双重检查版
 */
class singleton {
    // 在类的内部声明一个实例对象
    private static volatile singleton singleton;

    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象,在方法内部加个同步代码块,在代码块内部增加一个检查处理。 当调用该方法时,才去检查并创建一个实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        if (singleton == null) {
            synchronized (singleton.class) {
                if (singleton == null) {
                    singleton = new singleton();
                }
            }
        }
        return singleton;
    }
}

(3)优缺点:
  优点:线程安全,延迟加载,效率高。常用于多线程开发。

 

9、静态内部类

(1)步骤:
  step1:构造器私有化(防止通过new创建实例对象)
  step2:在类的内部定义一个静态内部类(只有被调用时,才会被加载),并在内部类中实例化对象。
  step3:向外暴露一个静态的公共方法,并在方法中调用静态内部类,用于获取实例对象。
(2)代码实现:

package singleton.pattern.demo7;

/**
 * 演示 单例模式,静态内部类版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.getsingleton();
        singleton singleton2 = singleton.getsingleton();
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 单例模式,静态内部类版
 */
class singleton {
    /**
     * 构造器私有化(防止通过new创建实例对象)
     */
    private singleton() {
    }

    /**
     * 静态内部类,在被调用的时候才会被加载,实现懒加载。 且内部使用静态常量实例化一个对象,保证了线程安全问题。
     */
    public static class singletoninstance {
        public static final singleton instance = new singleton();
    }

    /**
     * 向外暴露一个静态的公共方法用于获取实例对象,在方法内部加个同步代码块,在代码块内部增加一个检查处理。 当调用该方法时,才去检查并创建一个实例对象。
     * 
     * @return 实例对象
     */
    public static singleton getsingleton() {
        return singletoninstance.instance; // 调用静态内部类的静态属性
    }
}

(3)优缺点:
  优点:利用jvm的类加载机制,保证了实例化对象时只有一个线程,从而线程安全。在被调用时静态内部类才会被加载并实例化对象,从而实现懒加载,效率高。

(4)uml图:

创建型设计模式--单例模式

 

10、枚举

(1)步骤:
  step1:定义一个枚举类型。
  step2:调用即可
(2)代码实现:

package singleton.pattern;

/**
 * 演示 单例模式,枚举版
 *
 */
public class demo {
    public static void main(string[] args) {
        singleton singleton1 = singleton.instacne;
        singleton singleton2 = singleton.instacne;
        system.out.println(singleton1 == singleton2); // 由于获取的为同一个对象,所以输出为true
    }
}

/**
 * 单例模式,枚举版
 */
enum singleton {
    instacne;
    public void show() {
        system.out.println("hello world");
    }
}

(3)优缺点:
  优点:使用枚举类型创建(enum本质是个继承java.lang.enum类的final class),保证线程安全,且可以防止反序列化重新创建新的对象。

 

11、jdk中的单例模式举例(runtime)

(1)部分源码

public class runtime {
    private static runtime currentruntime = new runtime();

    /**
     * returns the runtime object associated with the current java application.
     * most of the methods of class <code>runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>runtime</code> object associated with the current
     *          java application.
     */
    public static runtime getruntime() {
        return currentruntime;
    }

    /** don't let anyone else instantiate this class */
    private runtime() {} 
}

(2)可以看到上述代码中采用的是 饿汉式单例模式(静态变量版)。

12、单例模式使用注意

(1)当频繁创建、销毁某个对象时,可以采用单例模式。
(2)使用单例模式时,需调用相关方法获取实例,而不是通过new。
(3)当创建对象消耗资源过多时,但又经常使用时,可以采用单例模式创建。