单例模式

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。
什么是唯一实例？

单例模式的应用场景：

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

在java中每当我们需要调用对象中的方法或者操作成员变量都需要通过new方法创建一个实例。直接上代码：

package singleDemo;

public class Dog {

}

package singleDemo;

public class Test {

public static void main(String []args){

    Dog dog1 = new Dog();

    Dog dog2 = new Dog();

    System.out.println(dog1 == dog2);
}

}

会发现输出为false，因为java中每创建一个实例对象，都会单独开辟一块内存空间。

要保证我们一个类成为系统的唯一实例，就需要使用单例模式，代码跟上：

package singleDemo;

public class SingleDog {

private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。

private static SingleDog singleDog = new SingleDog(); //创建一个静态的实例

/**
 * 通过公有方法将类的实例返回出去
 * @return
 */
public static SingleDog getSingleDog(){
    return singleDog;
}

}

package singleDemo;

public class Test {
public static void main(String []args){

  SingleDog singleDog1 = SingleDog.getSingleDog();

  SingleDog singleDog2 = SingleDog.getSingleDog();

    System.out.println(singleDog1==singleDog2); //发现输出为true
}

}

此时发现两个对象完全一样，证明singleDog1 和singleDog2 都指向了同一个实例，这就是所谓的单例模式，有没有很简单的感觉。这种模式也在单例模式中叫做饿汉模式。说到饿汉模式，就要提到单例模式的两种情况：饿汉模式和懒汉模式。
下面我们来看看懒汉模式，直接上代码：
public class SingleDog {

private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。

private static SingleDog singleDog; //创建一个静态的实例

/**
 * 通过公有方法将类的实例返回出去
 * @return
 */
public static SingleDog getSingleDog(){
    if(singleDog == null){
        singleDog = new SingleDog();
    }
    return singleDog;
}

}
其实就改了一段代码，当我们需要使用类的实例时，我们先看内存中有没有，如果没有的话，我们才创建这个实例。
单例模式l两种方式的优点和缺点：
1.饿汉式：类一加载，对象已经存在，但是浪费内存资源。（开发常用）
2.懒汉式：类加载进来，没有对象，只有调用，才会创建，可以实现 lazy loading。（在多线程下面不安全）
这里笔者不在概述为什么在多线程下不安全，如果不了解的话请补充线程相关知识点。下边懒汉模式是线程安全的写法，直接贴代码。
public class SingleDog {

private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。

private static SingleDog singleDog; //创建一个静态的实例

/**
 * 通过公有方法将类的实例返回出去
 * @return
 */
public static synchronized SingleDog getSingleDog(){   //加锁
    if(singleDog == null){
        singleDog = new SingleDog();
    }
    return singleDog;
}

}
上面在懒汉模式上可以实现线程安全，但是每次调用都会进行锁的判断，严重影响效率，开发基本不用。难道没有既可以保证线程安全也可以保证懒加载的方式？当然有，我们直接上代码。
public class SingleDog {

private SingleDog(){} //构造函数私有化，保证其他地方不能创建该类的实例。

private static SingleDog singleDog; //创建一个静态的实例

/**
 * 通过公有方法将类的实例返回出去
 * @return
 */
public static SingleDog getSingleDog(){   
    if(singleDog == null){                 
        synchronized (SingleDog.class){  //加锁
            if(singleDog == null){
                singleDog = new SingleDog();
            }
        }
    }
    return singleDog;
}

}
我们将锁加在代码块上，这样只有第一次申请对象时才会进行锁的判断，以后申请对象时只会进行空判断， 如果不为空，直接返回了singleDog，不会进行锁的判断，这样实现既保证了效率又保证了线性安全。说到这里单例模式两种基本的实现方式相信大家基本都已经了解了。
总结一下：
1.单例模式保证了内存中唯一对象。
2.单例模式分为饿汉模式和懒汉模式。
3.饿汉模式：在类一加载就申请对象， 浪费内存资源。
4.懒汉模式：在第一次掉才申请对象，可以实现懒加载，在代码块上加上锁。既可以保证效率，也可以实现线程安全。
我们开发时具体是用饿汉模式还是懒汉模式需要根据具体情况而定。笔者水平有限，如果有什么不正确的地方，欢迎联系我纠错。