饥汉模式:
* 优点:当类被加载的时候,已经创建好了一个静态的对象,因此,是线程安全的;
* 缺点:这个对象还没有被使用就被创建出来了。
public class HungrySingleton {
// 私有化静态成员变量,已初始化
private static HungrySingleton test = new HungrySingleton();
// 私有化构造方法
private HungrySingleton() {
}
// 提供一个公共的接口供外界获得单例对象
// 不需要同步(类加载时已经初始化,不存在多线程的问题)
// 始终只有一个对象
public static HungrySingleton getInstance() {
return test;
}
}
懒汉模式:
* 优点:按需加载对象,只有对象被使用的时候才会被创建
* 缺点:这种写法不是线程安全的,例如当第一个线程执行判断语句if(test = null)时,
* 第二个线程执行判断语句if(test = null),接着第一个线程执行语句test = new Test(),
* 第二个线程也执行语句test = new Test(),在这种多线程环境下,可能会创建出来两个对象。
public class LazySingleton {
// 私有化静态成员变量,防止外界修改,没有实例化
private static LazySingleton test = null;
// 私有化构造方法,防止外界调用,保证对象是单例对象
private LazySingleton() {
}
// 提供一个公共的接口供外界获得单例对象
// 当多个线程都在调用此方法时,必须保证只有一个单例对象生成,
// 这里采用对同步代码块加上
// 因为成员变量是静态的,该方法也必须是静态方法
public static LazySingleton getInstance() {
if (test == null) {
// 静态方法,使用当前类本身充当进程锁
synchronized (LazySingleton.class) {
test = new LazySingleton();
}
}
return test;
}
}
为什么单例模式创建的实例要设置为静态的?
/**
* 单例模式实现过程如下:
* 首先,将该类的构造函数私有化(目的是禁止其他程序创建该类的对象);
* 其次,在本类中自定义一个对象(既然禁止其他程序创建该类的对象,就要自己创建一个供程序使用,否则类就没法用,更不是单例);
* 最后,提供一个可访问类自定义对象的类成员方法(对外提供该对象的访问方式)。
* 直白的讲就是,你不能用该类在其他地方创建对象,而是通过该类自身提供的方法访问类中的那个自定义对象。
* 那么问题的关键来了,程序调用类中方法只有两种方式:
* ①创建类的一个对象,用该对象去调用类中方法;
* ②使用类名直接调用类中方法,格式“类名.方法名()”;
* 上面说了,构造函数私有化后第一种情况就不能用,只能使用第二种方法。
* 而使用类名直接调用类中方法,类中方法必须是静态的,而静态方法不能访问非静态成员变量,因此类自定义的实例变量也必须是静态的。
* 这就是单例模式唯一实例必须设置为静态的原因。
*/