单例模式

单例模式

保证一个类仅有一个实例(sInstance), 并提供一个访问该实例的全局访问点(getInstance).
这就意味着单例通常有如下两个特点:

1. 构造函数是私有的(避免别的地方创建它)
2. 有一个static的方法来对外提供一个该单例的实例.

优点：

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用（比如写文件操作）。

缺点：

1. 没有接口，不能继承

使用场景：

1. 要求生产唯一序列号。
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

---

1 饿汉式单利

饿汉式单例
顾名思义, 就是很饿, 不管三七二十一先创建了一个实例放着, 而不管最终用不用.

缺点：

• 在不需要的情况下就随便生成对象，消耗内存，不可取

2 懒汉式单例

"懒", 也就是现在懒得创建, 等有用户要用的时候才创建.

3 线程安全的懒汉式单例

利用synchronized关键字来修饰对外提供该类唯一实例的接口(getInstance)来确保在一个线程调用该接口时能阻塞(block)另一个线程的调用, 从而达到多线程安全, 避免重复创建单例.

缺点：

• synchronized有很大的性能开销. 而且在这里我们是修饰了getInstance方法, 意味着, 如果getInstance被很多线程频繁调用时, 每次都会做同步检查, 会导致程序性能下降.实际上我们要的是单例, 当单例已经存在的时候, 我们是不需要用同步方法来控制的

4 双重检查单例模式

这种方式的同步使用会减少同步锁的占用比例

缺点

• 容易出现理解错误 不加volatile 关键字引发不必要的错误

5 静态内部类单例

这种方式, 通过JVM的类加载方式(虚拟机会保证一个类的初始化在多线程环境中被正确的加锁、同步), 来保证了多线程并发访问的正确性.

另外, 由于静态内部类的加载特性 --- 在使用时才加载, 这种方式也达成了懒加载的目的.

缺点

• 完美 ，依赖于特定的语言

---

代码实例

package com.jack.idea.test.designmode;

/**
 * 单例模式
 *
 * @author ljs.song
 * @date 2017-12-28 15:24
 */
public class Singleton {

    public static void main(String[] args) {
        XiaoLong xiaoLong = new XiaoLong();
        System.out.println(xiaoLong.share("小龙龙布兰妮四点分享英雄联盟王者之路和绝地求生吃鸡之秘"));


        LeiLei leiLei = new LeiLei();
        System.out.println(leiLei.share("磊磊四点分享英雄联盟王者之路和绝地求生吃鸡之秘"));
    }

}

/**
 * 小龙龙布兰妮分享
 */
class XiaoLong{

    public Share share(String title){
        Share share = SimpleSingleton.getInstance();
        share.title(title);
        return share;
    }
}

/**
 * 磊磊分享
 */
class LeiLei{
    public Share share(String title){
        Share share = SimpleSingleton.getInstance();
        share.title(title);
        return share;
    }
}

/**
 * 分享整理文件
 */
class Share{
    private String title;

    public void title(String title){
        this.title = title;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Share{");
        sb.append("fileName : " + this.hashCode()).append(" ,");
        sb.append("title='").append(title).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

/**
 * 饿汉式
 */
class SimpleSingleton extends Share{

    private static SimpleSingleton simpleSingleton = new SimpleSingleton();

    private SimpleSingleton(){}

    public static SimpleSingleton getInstance(){
        return simpleSingleton;
    }
}

/**
 * 懒汉式（饱汉）
 */
class LazySingleton extends Share{
    private static LazySingleton lazySingleton;

    private LazySingleton(){}

    public static LazySingleton getInstance(){
        //在有人第一次分享后才创建分享的整理文件
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

//线程安全的懒汉单例  synchronized
class SynchronizedLazySingleton extends Share{
    private static SynchronizedLazySingleton synchronizedLazySingleton;

    private SynchronizedLazySingleton(){}

    //粗鲁人也，直接锁定整个方法
    public static synchronized SynchronizedLazySingleton getInstance(){
        //在有人第一次分享后才创建分享的整理文件
        if(synchronizedLazySingleton == null){
            synchronizedLazySingleton = new SynchronizedLazySingleton();
        }
        return synchronizedLazySingleton;
    }
}

/**
 * 双重检查锁定单例
 */
class DCLLazySingleton extends Share{
    /**
     * 这里添加volatile 关键字是因为下面注释 问题根源 S处对象的创建
     * 1.分配内存 2.初始化对象 3. 引用指向分配的地址
     * 可能会出现指令重排序
     * 假如 顺序变为 1,3,2 就有可能导致线程A走进S处发生重排序
     * 线程B 在代码N处发现对象不为空，但是却还没初始化的尴尬
     */
    private static volatile DCLLazySingleton dclLazySingleton;

    private DCLLazySingleton(){}

    public static DCLLazySingleton getInstance(){
        //第一次检查 N
        if(dclLazySingleton == null){
            synchronized (DCLLazySingleton.class){
                //第二次检查
                if(dclLazySingleton == null) {
                    // 问题根源 S
                    dclLazySingleton = new DCLLazySingleton();
                }
            }
        }
        return dclLazySingleton;
    }
}

/**
 * 静态内部类单例
 */
class InnerClassSingleton{

    private InnerClassSingleton(){}

    public static InnerClassSingleton getInstance(){
        return Inner.INNER_CLASS_SINGLETON;
    }

    static class Inner{
        private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
    }
}