设计模式: 对问题行之有效的解决方式, 其实它是一种思想.
单例设计模式
解决的问题:就是可以保证一个类在内存中的对象唯一性. 即单个实例.
比如对于A 和 B 两个程序使用同一个配置信息对象时, A 对配置信息作出修改, B 也与之对应的更新配置信息, 即需要保证该对象的唯一性.
如何保证对象唯一性呢?
不允许其他程序用 new 创建该类对象
在该类中创建一个本类实例
对外提供一个方法让其他程序可以获取该对象.
步骤:
私有化该类构造函数
通过 new 在本类中创建一个本类对象
定义一个公有方法, 将创建的对象返回
两种方式
饿汉式: 类一加载, 对象就存在了.
懒汉式: 类加载进来, 没有对象, 只有调用 getInstance 方法时, 才会创建对象.
也称为 单例设计模式的延迟加载模式. 但是, 懒汉式在多线程访问时,存在安全隐患.
// 第一种方式: 饿汉式
class Single
{
Single s = new Single(); // 在本类中创建一个本类对象
private Single(){} // 私有化该类构造函数
// 定义一个公有方法, 将创建的对象返回. 用于返回对象 s, 所以返回类型 Single
public Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss = Single.getInstance();
}
}
/*
分析一: main 函数中, getInstance 方法调用不能使用对象调用, 只能使用类名调用.
所以 Single 类中该方法需要使用 static 修饰.
分析二: getInstance 方法为静态方法, 它访问的内容必须是静态的,所以对象 s 也需要静态修饰.
*/
// 改进
class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance() // 提供该方法访问实例对象 s, 是为了对象的可控
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss = Single.getInstance();
}
}
// 第二种方式: 懒汉式
// 类加载进来, 没有对象, 只有调用 getInstance 方法时, 才会创建对象.
class Single2
{
private static Single2 s = null;
private Single(){}
public static Single2 getInstance()
{
if(s==null)
s = new Single2();
return s;
}
}
// 示例:下列代码的输出结果
class SingleDemo
{
public static void main(String[] args)
{
Test t1 = Test.getInstance();
Test t2 = Test.getInstance();
t1.setNum(10);
t2.setNum(20);
System.out.println(t1.getNum()); // 输出 20
System.out.println(t2.getNum()); // 输出 20
}
}
class Test
{
private int num;
private static Test t = new Test();
private Test(){}
public static Test getInstance()
{
return t;
}
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}
}
// 懒汉式二:避免多线程同时调用getInstance()方法, 可以使用关键字synchronized
class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton(){}
public synchronized static LazySingleton getInstance() {
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
// 懒汉式三:为提高系统性能,对"instance = new LazySingleton()"进行锁定
class LazySingleton{
private static LazySingleton instance = null;
private LazySingleton(){}
public static LazySingleton getInstance(){
if(instance == null){ // 此处,有可能造成单例对象不唯一
synchronized(LazySingleton.class){
instance = new LazySingleton();
}
}
return instance;
}
}
// 懒汉式四:双重检查锁定(Double-Check Locking)
class LazySingleton{
// 注意,此处增加修饰符 volatile
private volatile static LazySingleton instance = null;
private LazySingleton(){}
public static LazySingleton getInstance(){
// 第一重判断
if(instance == null){
// 锁定代码块
synchronized(LazySingleton.class){
// 第二重判断
if(instance == null){
instance = new LazySingleton();
}
}
}
return instance;
}
}
//单例第三种方式: Initialization Demand Holder(IoDH)技术
// 在单例类中增加一个静态(static)内部类
class Singleton{
private Singleton(){}
// 静态类
private static class HolderClass {
private final static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return HolderClass.instance;
}
public static void main(String args[]){
Singleton s1, s2;
s1 = Singleton.getInstance();
s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
_参考资料_
- [JavaSE 基础视频(毕向东)](https://www.bilibili.com/video/av3092292/#page=4)
- [单例模式中的双重检查](http://blog.csdn.net/chenchaofuck1/article/details/51702129)
