单例模式

饥汉模式：

* 优点：当类被加载的时候，已经创建好了一个静态的对象，因此，是线程安全的；

* 缺点：这个对象还没有被使用就被创建出来了。

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;

}

}