Design Pattern_Singleton(单件模式)和Double-Checked Locking(双重检查锁定)

Singleton 模式
意图：你希望只拥有一个对象，但不用全局对象来控制对象的实例化。
问题：几个不同的客户对象需要引用同样的对象，你希望确保自己拥有这种对象不超过一个。
解决方案：保证一个实例。
参与者与协作者：客户对象只能通过getInstance 方法创建Singleton的实例。
效果:客户对象不需要关心是否已经有Singleton的实例存在。这可以在Singleton内部得到控制。
实现：
  1.在Singleton类中添加一个静态成员变量，它引用所需要的对象(初始化为NULL)。
 2.添加一个公共静态方法：如果这个成员变量的值是NULL,就对这个类进行实例化(并设置成员变量的值)，然后返回成员变量的值。
 3.将构造子的状态设置为protected或private，这样就没有人可以直接对这个类进行实例化而绕过静态构造子机制。

单例模式用的很多，当一个对象在全局有且只存在一个且被多个对象调用时我一般都考虑用singleton

比如现在做的一个android的小项目里面，有一个是本地的数据库对象UserDB，存储的是User的相关数据，并对User进行相关管理

如果我不用单例模式，可能的做法就是构造一个简单的类，然后在application里初始化，在activity需要时通过application获取

这就造成语句很不好理解application.userdb.method，且耦合降低了，如果需要在其它项目里用就必须在application初始化，

如果使用singleton就很好理解了，使用时直接UserDB.getInstance().methon

这里有一篇对singleton多线程的讨论

http://blog.csdn.net/liushuijinger/article/details/9069801

还有一篇类似的E文

http://www.ibm.com/developerworks/java/library/j-dcl/index.html#

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package singleton;

/**
 *
 * @author blacklaw
 */
public class Singleton {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("main Go");
        UserDB.getInstance().addUser("blacklaw");
        UserDB.getInstance().removeUser("blacklaw");
    }
}
class UserDB{
    private static UserDB instance;
    
    private UserDB(){};
    
    public static UserDB getInstance(){
        if(instance == null){
            System.out.println("UserDB load instance");
            instance = new UserDB();
        }
        System.out.println("getInstance Go");
        return instance;
    }
    
    public void addUser(String username){
        System.out.println("add:" + username);
    }
    
    public void removeUser(String username){
        System.out.println("remove:" + username);
    }
}

http://en.wikipedia.org/wiki/Double-checked_locking

Double checked lock 是为了保证事物的原子性，在第一检查为null后，开始获取琐，然后多条进程进入队列

第二判断null是为了避免后续队列执行new操作，浪费内存

// Works with acquire/release semantics for volatile
// Broken under Java 1.4 and earlier semantics for volatile
class Foo {
    private volatile Helper helper = null;
    public Helper getHelper() {
        Helper result = helper;
        if (result == null) {
            synchronized(this) {
                result = helper;
                if (result == null) {
                    helper = result = new Helper();
                }
            }
        }
        return result;
    }
 
    // other functions and members...
}