Java设计模式の单利模式

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

public class Q {
    //多线程
    private static Q uniqueInstance = null;
    private Q(){
        
    }
    public static Q getInstance(){
        if (uniqueInstance==null) {//当线程1执行此语句后，判断通过，
            /*正准备执行uniqueInstance=new Q()时，线程2抢占到了cpu资源，
             *切换到线程2开始执行，线程2会发现uniqueInstance还是null，所以会创建对象，创建完后，
             *而当切换到线程1时，发现线程1已经进入if判断，所以也会创建一个新uniqueInstance，
             *此时线程1创建的uniqueInstance和线程2创建的uniqueInstanc是不一样的
             **/
            uniqueInstance=new Q();
        }
        return uniqueInstance;
    }
}

/**
 * 优化方式1
 * 方法添加同步锁
 * 优点：使用方便
 * 缺点：当线程很多的情况下，非常耗费资源
 * @author yxm
 *
 */
public class Optimization_Singleton_1 {
    private static Optimization_Singleton_1 uniqueInstance = null;
    private Optimization_Singleton_1(){
        
    }
    public synchronized static Optimization_Singleton_1 getInstance(){
        if (uniqueInstance==null) {
            uniqueInstance=new Optimization_Singleton_1();
        }
        return uniqueInstance;
    }
}

/**
 * 优化方式2
 * 急切创建对象
 * 优点：不会因为加锁而耗费资源
 * 缺点：当不使用此类时，照样会耗费内存
 * @author yxm
 *
 */
public class Optimization_Singleton_2 {
    private static Optimization_Singleton_2 uniqueInstance = new Optimization_Singleton_2();
    private Optimization_Singleton_2(){
        
    }
    public static Optimization_Singleton_2 getInstance(){
        if (uniqueInstance==null) {
            uniqueInstance=new Optimization_Singleton_2();
        }
        return uniqueInstance;
    }
}

/**
 * 优化方式3
 * 双重检查加锁
 * 较完美
 * @author yxm
 *
 */
public class Optimization_Singleton_3 {
    private volatile static Optimization_Singleton_3 uniqueInstance = null;//volatile给编译器使用，保证线程安全
    private Optimization_Singleton_3(){
        
    }
    public synchronized static Optimization_Singleton_3 getInstance(){
        if (uniqueInstance==null) {
　　　　　　　//只有等线程1把对象创建好了，其他线程才会进入以下代码块
            synchronized(Optimization_Singleton_3.class){
                if (uniqueInstance==null) {
                    uniqueInstance=new Optimization_Singleton_3();
                }
            }
        }
        return uniqueInstance;
    }
}

public class ChocolateFactory {
    private boolean empty;
    private boolean boiled;
    
    public ChocolateFactory(){
        empty=true;
        boiled=false;
    }
    //填充
    public void fill(){
        if (empty) {
            empty=false;
            boiled=false;
        }
    }
    //加热
    public void boil(){
        if (!boiled) {
            boiled=true;
        }
    }
    //排出
    public void drain(){
        if (!empty&&boiled) {
            empty=true;
        }
    }
}

public class ChocolateFactoryInSingleton {
    private boolean empty;
    private boolean boiled;
    public static ChocolateFactoryInSingleton uniqueInstance=null;
    private ChocolateFactoryInSingleton(){
        empty=true;
        boiled=false;
    }
    public static ChocolateFactoryInSingleton getInstance(){
　　　　 //此处确保不同的巧克力不会进入同一条生产线
        if (uniqueInstance==null) {
            uniqueInstance=new ChocolateFactoryInSingleton();
        }
        return uniqueInstance;
    }
    //填充
    public void fill(){
        if (empty) {
            empty=false;
            boiled=false;
        }
    }
    //加热
    public void boil(){
        if (!boiled) {
            boiled=true;
        }
    }
    //排出
    public void drain(){
        if (!empty&&boiled) {
            empty=true;
        }
    }
}