单例模式：用来创建独一无二的，只能有一个实例的对象的入场券。

   一些对象，我们只需要一个:(线程池，缓存，对话框等等)，事实上，这类对象只能有一个实例。如果制造多了了，会导致许多问题，如行为异常、资源使用过量。

   全局变量的缺点，如果将对象赋值给一个全局变量，那么必须在程序一开始就创建好对象，万一这个对象非常消耗资源，而程序在这次的执行过程中又一直没用到它，就形成了浪费。


public class Singleton {
    private static Singleton uniInstance;
    public int ID;
                                                                                                                                                                                                                                                                                                                                   
    private Singleton(int id) {
        ID = id;
    }
                                                                                                                                                                                                                                                                                                                                   
    public static Singleton getInstance(int id) {
        if (uniInstance == null) {
            uniInstance = new Singleton(id);
        }
                                                                                                                                                                                                                                                                                                                                   
        return uniInstance;
    }
}
                                                                                                                                                                                                                                                                                                                                  
//----------------------Main------------------------
                                                                                                                                                                                                                                                                                                                                  
public class Main {
    public static void main(String[] args) {
        Singleton mSingleton,nSingleton;
        mSingleton = Singleton.getInstance(3);
        nSingleton = Singleton.getInstance(4);
        System.out.println(mSingleton.ID);
        System.err.println(nSingleton.ID);
    }
}


   打印出来的结果，都是3，说明mSingleton与nSingleton指向同一对象，保证了实例的唯一性。

请注意，如果不需要这个实例，它就永远不会产生。

   上述为单例模式的经典实现，再看下单例模式的定义：

   确保一个类只有一个实例，并提供一个全局访问点。

   把类设计成自己管理的一个单独实例，同时也避免其他类再自行产生实例。并且提供了这个实例的全局访问点：当你需要实例时，向类查询，它会返回单个实例。

   需要注意的是，Singleton声明的实例对象必须是全局的。假设上述代码中的

Singleton mSingleton,nSingleton;

是分别放在不同线程中声明的，那么getInstance获得的实例就不符合单件模式规则了。


   巧克力工厂：

/**
 * 这是一个巧克力锅炉控制器，锅炉做的事，就是把巧克力和牛奶融在一起， 然后送到下一个阶段，以制造成巧克力棒
 */
                                                                  
public class ChocolateBoiler {
    private boolean empty;// 代码开始时，锅炉是空的
    private boolean boiled;
    public ChocolateBoiler() {
        empty = true;
        boiled = false;
    }
                                                                  
    /**
     * 在锅炉内填入原料时，锅炉必须是空的。 一旦填入原料，就把empty和boiled标志设置好
     */
    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = true;
            // 在锅炉内填满巧克力和牛奶的混合物
        }
    }
                                                                  
    private boolean isEmpty() {
        return empty;
    }
                                                                
    private boolean isBoiled() {
        return boiled;
    }
                                                                  
    /**
     * 锅炉排出时，必须是满的（不可以是空的）而且是煮过的。排出完毕后，把empty标志设回true
     */
    public void drain() {
        if (!isEmpty() && isBoiled()) {
            // 排除煮沸的巧克力和牛奶
            empty = true;
        }
    }
                                                                  
    /**
     * 煮混合物时，锅炉必须是满的，并且是没有煮过的，一旦煮沸后，就把boiled标志设为true
     */
    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            // 将炉内物煮沸
            boiled = true;
        }
    }
}


   注意到了，如果同时存在两个以上ChocolateBoiler实例存在，可能会存在的问题：排除500升的为主费的混合物，或者锅炉已经满了还继续放原料，或者锅炉内还没放原料就开始空烧。修改下代码：

public class ChocolateBoiler {
    private boolean empty;// 代码开始时，锅炉是空的
    private boolean boiled;
    private static ChocolateBoiler uniChocolateBoiler;
                                       
    private ChocolateBoiler() {
        // TODO Auto-generated constructor stub
        empty = true;
        boiled = false;
    }
                                       
    public static ChocolateBoiler getInstance() {
        if (uniChocolateBoiler == null) {
            uniChocolateBoiler = new ChocolateBoiler();
        }
        return uniChocolateBoiler;
    }
    //后面代码省略
}


   又遇到了麻烦，fill方法允许在加热的过程中继续假如原料，这可是会溢出五百升的原料。是多线程导致的问题。    

   处理多线程，只要把getInstance()变成同步(synchronized)方法：

class Singleton {
    private static Singleton uniqueInstance;
                              
    private Singleton() {
    }
                              
    public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}


综述

   1.单件模式确保程序中一个类最多只有一个实例

   2.单件模式也提供访问这个实例的全局点

   3.在java中实现单件模式需要

   （1）私有构造器

   （2）一个静态方法

   （3）一个静态变量

   4.确定在性能和资源上的限制，然后小心地选择适当的方案来实现单件，以解决多线程的问题


由于最近一直在学习Golang，所以之后学习的设计模式如果没有涉及到Java特有的语言特性，学习笔记中的源码将由Golang来完成