学步园

单例模式

单例模式可以说是最简单的设计模式了，当我们需要保持状态一致，或者是缩减资源开销的时候我们都会用到单例模式。

就如我们的实验室有三个老总，以前富裕的时候每个老总都有一个女秘书

class NvMiShu {

}

public class Singleton {
    public static void main(String[] args) {
        // 老总A的秘书
        NvMiShu mishuA = new NvMiShu();

        // 老总B的秘书
        NvMiShu mishuB = new NvMiShu();

        // 老总C的秘书
        NvMiShu mishuC = new NvMiShu();
    }
}

但是最近市场不景气，我们的人+衣服套件不好卖了，老总们只能共用一位秘书了，所以辞退两个秘书后，剩下的一个秘书只能改变工作机制才能满足三个老总的需求（请宅男程序员们不要脑补，我是一个正直的程序猿），

class NvMiShu {
    private static NvMiShu miShu = new NvMiShu();

    private NvMiShu() {
    }

    public static NvMiShu getInstance() {
        return miShu;
    }
}

public class Singleton {
    public static void main(String[] args) {
        // 老总A的秘书
        NvMiShu mishuA = NvMiShu.getInstance();
        // 老总B的秘书
        NvMiShu mishuB = NvMiShu.getInstance();
        // 老总C的秘书
        NvMiShu mishuC = NvMiShu.getInstance();
        // 其实老总们的秘书只有一个，只是不同老总招唤的时候穿上不同的齐X小短裙
    }
}

但是当我们的经济更加的拮据的时候，有人提出当老总们都不需要秘书的时候，我们其实不需要秘书啊，只有当有一个老总有需求的时候，招一个秘书好了，于是秘书处又做了改变：

class NvMiShu {
    private static NvMiShu miShu;

    private NvMiShu() {
    }

    public static NvMiShu getInstance() {
        if (miShu == null) {
            miShu = new NvMiShu();
        }
        return miShu;
    }
}

如此这般了以后，很久的时间工作得都很顺利，老总们都能得到秘书很好的服务。

直到有一次，A老总需要秘书的服务，当时前一个秘书因为长时间得不到老总的招唤已经辞退了，所以秘书处的人就去招人了，

但是这时候B老总也需要秘书的服务，秘书处还没有秘书所以又去招人了，这下一下子招回来两个秘书，问题就出现了，所以秘书处只能再次改变工作机制

class NvMiShu {
    private static NvMiShu miShu;

    private NvMiShu() {
    }

    public synchronized static NvMiShu getInstance() {
        if (miShu == null) {
            miShu = new NvMiShu();
        }
        return miShu;
    }
}

这样当多个老总同时招呼秘书的时候，就得排队等上一个老总用完才轮到下一个老总用。这又导致了老总们等待的时间变长，老总的意思是当没有秘书的时候我们排队等等也行，但是如果有秘书了，我们就不需要排队了，可以一起用啊(我真不想说的这么不符合我的风格，但是事实就是这样啊)。 秘书处只能又做了一些改变。

class NvMiShu {
    private static NvMiShu miShu;
    private static final Object o = new Object();

    private NvMiShu() {
    }

    public static NvMiShu getInstance() {
        if (miShu == null) {// #1
            synchronized (o) {
                if (miShu == null) {// #2 #1和#2处两次判断是为了避免多线程同时调用，都通过#1处的校验
                    miShu = new NvMiShu();
                }
            }
        }
        return miShu;
    }
}

以下是完整的一个单例模式，

class NvMiShu {
    private static NvMiShu miShu;
    private static final Object o = new Object();

    private NvMiShu() {
    }

    public static NvMiShu getInstance() {
        if (miShu == null) {// #1
            synchronized (o) {
                if (miShu == null) {// #2 #1和#2处两次判断是为了避免多线程同时调用，都通过#1处的校验
                    miShu = new NvMiShu();
                }
            }
        }
        return miShu;
    }
}

public class Singleton {
    public static void main(String[] args) {
        // 老总A的秘书
        NvMiShu mishuA = NvMiShu.getInstance();
        // 老总B的秘书
        NvMiShu mishuB = NvMiShu.getInstance();
        // 老总C的秘书
        NvMiShu mishuC = NvMiShu.getInstance();
        // 其实老总们的秘书只有一个，只是不同老总招唤的时候穿上不同的齐X小短裙
    }
}

 

因为单例模式比较简单，以上只为搏君一笑罢了。