设计模式学习笔记（一、创建型-单例模式）

目录：

• 什么是单例模式
• 为什么要使用单例模式
• 如何实现单例模式

什么是单例模式

一个类只允许创建一个实例或对象，那么这个类就叫做单例类，这种设计模式就叫做叫做单例模式。

为什么要使用单例模式

1、它可以解决资源访问冲突：

首先我们先看一段代码

public class Logger {

    private FileWriter fileWriter;

    public Logger() throws IOException {
        File file = new File("E:\codeTest\log.txt");
        // true >>> 写入的字符追加到文件末尾
        fileWriter = new FileWriter(file, true);
    }

    public void log(String message) throws IOException {
        fileWriter.write(message);
    }
}

public class UserController {

    private Logger log = new Logger();

    public UserController() throws IOException {
    }

    public void login(String username, String password) throws IOException {
        log.log(MessageFormat.format("login username={0} password={1}", username, password));
    }
}

public class OrderController {

    private Logger log = new Logger();

    public OrderController() throws IOException {
    }

    public void find(long orderId) throws IOException {
        log.log(MessageFormat.format("find orderId={0}", orderId));
    }
}

乍一看正常情况下的确是没有问题的，但是如果是在高并发场景下，便可能会造成OrderController或UserController中追加到文件末尾的日志会覆盖掉另一方的输入。

比如order和user同时竞争日志文件的资源，然后他们两个拿到的文件又是同一份；此时order向要在偏移量为100的位置添加文字“A”，user也要在偏移量为100的位置添加文字“B”。

当order执行完后，偏移量为100的数据便为A，紧接着B也执行了同样的操作，所以便把偏移量100的数据给覆盖掉了。

———————————————————————————————————————————————————————

解决问题的办法很多，最简单也可能最先想到的便是给log方法加锁了吧（因为是不同的对象，所以我们加类锁）。

public class Logger {

    private FileWriter fileWriter;

    public Logger() throws IOException {
        File file = new File("E:\codeTest\log.txt");
        // true >>> 写入的字符追加到文件末尾
        fileWriter = new FileWriter(file, true);
    }

    public void log(String message) throws IOException {
        synchronized (Logger.class) {
            fileWriter.write(message);
        }
    }
}

当然加锁是可以达到目的的，但使用单例模式的话解决思路更简单。

也不用创建那么多的Logger类，一方面可以节省内存空间，另一方面可以节省系统文件句柄。

public class LoggerBuff {

    private FileWriter fileWriter;
    private static LoggerBuff INSTANCE;

    static {
        try {
            INSTANCE = new LoggerBuff();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public LoggerBuff() throws IOException {
        File file = new File("E:\codeTest\log.txt");
        // true >>> 写入的字符追加到文件末尾
        fileWriter = new FileWriter(file, true);
    }

    public LoggerBuff getInstance() {
        return INSTANCE;
    }

    public void log(String message) throws IOException {
        synchronized (LoggerBuff.class) {
            fileWriter.write(message);
        }
    }
}

———————————————————————————————————————————————————————

2、它可以表示全局唯一的类：

从业务概念上，如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。

再比如，唯一递增ID号码生成器，如果程序中有两个对象，那就会存在生成重复ID的情况。所以，我们应该将ID生成器类设计为单例。

如何实现单例模式

• 构造函数需要是private访问权限的，这样才能避免外部通过new创建实例。
• 考虑对象创建时的线程安全问题。
• 考虑是否支持延迟加载。
• 考虑getInstance()性能是否高（是否加锁）。

1、饿汉：实例对象为静态，启动程序时加载。

public class HungryMan {
    
    private AtomicLong id = new AtomicLong(0);
    private static final HungryMan INSTANCE = new HungryMan();

    private HungryMan() {
    }

    public static HungryMan getInstance() {
        return INSTANCE;
    }

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

适用初始化占用资源较多或消耗时间过长，因为如果是这两种情况还是用的懒加载的话便会影响系统性能。

———————————————————————————————————————————————————————

2、懒汉：懒加载。

public class LazyMan {

    private AtomicLong id = new AtomicLong(0);
    private static LazyMan instance;

    private LazyMan() {
    }

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

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

支持懒加载，但并发度低。

———————————————————————————————————————————————————————

3、双重检测：既支持懒加载，又支持高并发的单例实现。

public class Double {

    private AtomicLong id = new AtomicLong(0);
    private static Double instance;

    private Double() {
    }

    public static Double getInstance() {
        if (instance == null) {
            synchronized (Double.class) {
                if (instance == null) {
                    instance = new Double();
                }
            }
        }
        return instance;
    }

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

———————————————————————————————————————————————————————

4、静态内部类：比双重检测更优雅的方式。

public class Inner {

    private AtomicLong id = new AtomicLong(0);

    private Inner() {
    }

    private static class SingletonHolder {
        private static final Inner INSTANCE = new Inner();
    }

    public static Inner getInstance() {
        return SingletonHolder.INSTANCE;
    }

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

———————————————————————————————————————————————————————

5、枚举：利用枚举特性实现单例。

public enum Enum {
    
    INSTANCE;

    private AtomicLong id = new AtomicLong(0);

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