设计模式之--单例模式

单例模式是设计模式中最常用的设计模式,其实现也相对简单.

单例模式指的是设计一个类,这个类的实例对象只存在一个.

下面介绍几种常用的单例模式实现方式:

1.饿汉式--静态变量--可用

package com.zk;
/**
 * Singleton1
 * @description 单例模式--饿汉式(静态变量)
 * @author zk
 * @date 2018年7月24日 下午9:03:32
 * @version 1.0
 */
public class Singleton1 {
    //定义一个私有的静态变量,存放这个类的实例对象,让当前类的get方法可以使用这个实例对象
    private static Singleton1 instance = new Singleton1();
    //私有的构造器,保证只能在当前类中新建对象
    private Singleton1(){}
    //提供一个公共静态的get方法,让其他类可以得到当前类的实例对象
    public static Singleton1 getInstance(){
        return instance;
    }
}

2.饿汉式--静态代码块--可用

package com.zk;
/**
 * Singleton2
 * @description 单例模式--饿汉式(静态代码块)
 * @author zk
 * @date 2018年7月24日 下午9:27:28
 * @version 1.0
 */
public class Singleton2 {
    //定义一个私有的静态变量
    private static Singleton2 instance;
    //通过静态代码块给私有的静态变量赋值,指向当前类的实例对象
    static{
        instance = new Singleton2();
    }
    //私有化构造方法,保证只有当前类可以创建实例对象
    private Singleton2(){};
    //公共的静态get方法,让其他类可以获得实例对象
    public static Singleton2 getInstance(){
        return instance;
    }
}

3.懒汉式--线程不安全--不可用

package com.zk;
/**
 * Singleton3
 * @description 单例模式--懒汉式--线程不安全,不可用
 * @author zk
 * @date 2018年7月24日 下午9:46:44
 * @version 1.0
 */
public class Singleton3 {
    private static Singleton3 instance;
    private Singleton3(){};
    public static Singleton3 getInstance(){
        //懒加载,用到的时候才创建对象,但是存在线程安全问题
        if(instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
}

4.懒汉式--同步方法--可用但不推荐

package com.zk;
/**
 * Singleton
 * @description 单例模式--懒汉式--同步方法--可用但不推荐
 * @author zk
 * @date 2018年7月24日 下午9:51:30
 * @version 1.0
 */
public class Singleton4 {
    private static Singleton4 instance;
    private Singleton4(){};
    //在Singleton3的基础上加上了synchronized变成同步方法,解决了线程不安全问题,但有性能问题
    public static synchronized Singleton4 getInstance(){
        if(instance == null){
            instance = new Singleton4();
        }
        return instance;
    }
}

5.懒汉式--双重检查+同步代码块--推荐使用

package com.zk;
/**
 * Singleton5
 * @description 单例模式--懒汉式--双重检查+同步代码块--推荐使用
 * @author zk
 * @date 2018年7月24日 下午9:59:50
 * @version 1.0
 */
public class Singleton5 {
    private static Singleton5 instance;
    private Singleton5(){}
    public static Singleton5 getInstance(){
        //第一次判断
        if(instance == null){
            //同步代码块,解决线程安全问题
            synchronized (instance) {
                //第二次判断
                if(instance == null){
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }
}

6.使用静态内部类--可用

package com.zk;
/**
 * Singleton6
 * @description 单例模式--静态内部类
 * @author zk
 * @date 2018年7月25日 下午9:01:32
 * @version 1.0
 */
public class Singleton6 {
    private Singleton6(){};
    //静态内部类
    private static class SingletonClass{
        private static final Singleton6 instance = new Singleton6();
    }
    public static Singleton6 getInstance(){
        return SingletonClass.instance;
    }
}

7.使用枚举--可用

package com.zk;
/**
 * Singleton7
 * @description 单例模式--枚举
 * @author zk
 * @date 2018年7月25日 下午9:10:29
 * @version 1.0
 */
public enum Singleton7 {
    INSTANCE;
}

总结:实现单例模式的方式有很多种,但是总结起来不外乎以下几点:

1.私有的构造方法,保证实例对象只能当前类能够创建

2.创建唯一的实例对象,并赋值给一个静态变量

3.静态的get方法,让外部类通过这个方法获取唯一的实例对象