java设计模式-单例(singleton)

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

如何保证对象唯一性呢？

思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

实现单例模式有两种：一种是饿汉式，在对象需要使用之前提前实例化，二是懒汉式，先不创建实例，等其他对象调用是再实例化。

一、饿汉式单例

public class Logger {
    private static final Logger instance = new Logger();

    private Logger() {
    }

    public static Logger getInstance() {
        return instance;
    }
}

 

二、懒汉式单例

/**
 * 我们已经实现了一个单例的logger，但是有人说不能支持延迟加载，所以我们需要实现一个能延迟加载的logger
 */
public class LazyLogger {
    private static  LazyLogger instance ;

    private LazyLogger() {
    }

    public static synchronized LazyLogger getInstance() {
        if(instance==null){
            instance=new LazyLogger();
        }
        return instance;
    }
}

 

三、静态内部类单例

/**
 * 有人说我们的lazyLogger有一把锁，影响性能，希望能既满足延迟加载，又提升效率
 * 其实可以通过静态内部类实现
 * 类加载的时候并不会创建instance，只有在getInstance执行的时候才会执行构造方法。
 */
public class StaticInnerLogger {
    private StaticInnerLogger() {
        System.out.println("constructor");
    }

   private static class InnerLogger{
        private static final StaticInnerLogger instance=new StaticInnerLogger();
    }

    public static StaticInnerLogger getInstance(){
        return InnerLogger.instance;
    }

    public static void main(String[] args) {
        System.out.println("hello,world");
        System.out.println(StaticInnerLogger.getInstance());
    }

}

 

四、枚举单例

/**
 * 利用枚举实现单例，这样的Logger必定是全局唯一的了
 */
public enum EnumLogger {
    LOGGER;

    private AtomicLong id = new AtomicLong(0);

    public long getId() {
        return id.incrementAndGet();
    }

    public static void main(String[] args) {
        EnumLogger logger = EnumLogger.LOGGER;
        long id = logger.getId();
    }
}