什么是单例模式？
保证一个类只有一个实例，并且提供一个访问该全局访问点。
单例模式的应用场景
1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.
单例模式的优缺点
优点：
1.在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例
2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
3.提供了对唯一实例的受控访问。
4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
5.允许可变数目的实例。
6.避免对共享资源的多重占用。
缺点：
1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
3.单例类的职责过重，在一定程度上违背了“单一职责原则”。
4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
单例的创建方式
饿汉式：类初始化时，会立即加载该对象，线程天生安全，调用效率高。
懒汉式：类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
具体代码案例如下：
1、饿汉式
类初始化时，会立即加载该对象，线程天生安全，调用效率高。
package cn.itchao.singleton;
public class Test01 {
private final static Test01 test = new Test01();
private Test01(){
}
public static Test01 getInstance(){
return test;
}
public static void main(String[] args) {
Test01 t1 = Test01.getInstance();
Test01 t2 = Test01.getInstance();
System.out.println(t1==t2);
}
}2.懒汉式-同步方法
package cn.itchao.singleton;
public class Test02 {
private static Test02 test02;
private Test02(){
}
public static synchronized Test02 getInstance(){
if(test02==null){
test02 = new Test02();
}
return test02;
}
public static void main(String[] args) {
Test02 t1 = Test02.getInstance();
Test02 t2 = Test02.getInstance();
System.out.println(t1==t2);
}
}3、懒汉式--双重检验锁
package cn.itchao.singleton;
public class Test03 {
private static Test03 test03;
private Test03(){}
public static Test03 getInstance(){
if(test03==null){
synchronized (Test03.class){
if(test03==null){
test03 = new Test03();
}
}
}
return test03;
}
public static void main(String[] args) {
Test03 t1 = Test03.getInstance();
Test03 t2 = Test03.getInstance();
System.out.println(t1==t2);
}
}4、懒汉式--静态内部类
package cn.itchao.singleton;
public class Test04 {
private Test04(){
}
static class StaticSingleton{
private static final Test04 test04 = new Test04();
}
public static Test04 getInstance(){
return StaticSingleton.test04;
}
public static void main(String[] args) {
Test04 t1 = Test04.getInstance();
Test04 t2 = Test04.getInstance();
System.out.println(t1==t2);
}
}总结：
优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。
劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。
5、饿汉式-枚举
package cn.itchao.singleton;
class Resource{}
enum Singleton{
INSTANCE;
private Resource instance;
Singleton(){
System.out.println("创建对象");
instance = new Resource();
}
public Resource getInstance(){
return instance;
}
}
public class Test05 {
public static void main(String[] args) {
Resource t1 = Singleton.INSTANCE.getInstance();
Resource t2 = Singleton.INSTANCE.getInstance();
System.out.println(t1==t2);
}
}思考问题：
1、选择何种方式创建单例
如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性好于饿汉式。
如果需要延迟加载，可以使用静态内部类或者懒韩式，相对来说静态内部类好于懒韩式。
2、如何防止使用反射漏洞攻击单例
在构造函数中，只能允许初始化化一次即可。
package cn.itchao.singleton;
import java.lang.reflect.Constructor;
public class Test06 {
private static volatile boolean flag = false;
private static Test06 test06 = new Test06();
private Test06(){
if(flag == false){
flag = !flag;
}else{
throw new RuntimeException("单例模式被侵犯");
}
}
public static Test06 getInstance(){
return test06;
}
public static void main(String[] args) {
try {
Class<?> forName = Class.forName("cn.itchao.singleton.Test06");
Constructor<?> declaredConstructor = forName.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
Object s1 = declaredConstructor.newInstance();
Object s2 = declaredConstructor.newInstance();
System.out.println(s1==s2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
执行结果：
java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
at cn.itchao.singleton.Test06.main(Test06.java:29)
Caused by: java.lang.RuntimeException: 单例模式被侵犯
at cn.itchao.singleton.Test06.<init>(Test06.java:15)
... 5 more
Process finished with exit code 0