饥汉模式：
* 优点：当类被加载的时候，已经创建好了一个静态的对象，因此，是线程安全的；
* 缺点：这个对象还没有被使用就被创建出来了。
publicclassHungrySingleton{
// 私有化静态成员变量，已初始化
privatestaticHungrySingleton test =newHungrySingleton();
// 私有化构造方法
privateHungrySingleton(){
}
// 提供一个公共的接口供外界获得单例对象
// 不需要同步（类加载时已经初始化，不存在多线程的问题）
// 始终只有一个对象
publicstaticHungrySingletongetInstance(){
returntest;
}
}
懒汉模式：
* 优点：按需加载对象，只有对象被使用的时候才会被创建
* 缺点：这种写法不是线程安全的，例如当第一个线程执行判断语句if(test = null)时，
* 第二个线程执行判断语句if(test = null),接着第一个线程执行语句test = new Test(),
* 第二个线程也执行语句test = new Test(),在这种多线程环境下，可能会创建出来两个对象。
publicclassLazySingleton{
// 私有化静态成员变量，防止外界修改，没有实例化
privatestaticLazySingleton test =null;
// 私有化构造方法，防止外界调用，保证对象是单例对象
privateLazySingleton(){
}
// 提供一个公共的接口供外界获得单例对象
// 当多个线程都在调用此方法时，必须保证只有一个单例对象生成，
// 这里采用对同步代码块加上
// 因为成员变量是静态的，该方法也必须是静态方法
publicstaticLazySingletongetInstance(){
if(test ==null) {
// 静态方法，使用当前类本身充当进程锁
synchronized(LazySingleton.class) {
test =newLazySingleton();
}
}
returntest;
}
public class Singleton1 {
/*饿汉式*/
/*
// 私有的构造方法
private Singleton1 (){};
// 私有的静态的全局变量
private static Singleton1 single = new Singleton1();
// 公共的 静态的全局方法
public static Singleton1 getInstance(){
return single;
}
*/
/* //懒汉式
//私有的构造方法
private Singleton1 (){};
//私有的静态的全局变量
private static Singleton1 single = null;
// 公共的静态的方法
public static Singleton1 getInstance(){
if(null == single){
single = new Singleton1();
}
return single;
}
*/
// 双重判定锁是
// 私有的构造方法
private Singleton1 single(){};
// 私有的静态的全局变量
private static Singleton1single;
// 公共的静态的方法
public static Singleton1 getInstance() {
if (null ==single) {
synchronized (single) {
if (null ==single) {
single =new Singleton1();
}
}
}
return single;
}
}
