java单例模式singleton回顾，如何实现单例模式
最近面试，用到了单例模式相关的知识，这里总结一下，温故知新。
单例模式，是java开发中经常会用到的一种模式。通常指的是在程序的执行过程中，只产生一个实例对象。单例模式通常有以下几种应用场景：
1，硬性需求，比如打印机的打印功能；
2，减小系统开销，比如在程序运行的过程中，可能会频繁的创建某一个类的实例，采用单例模式可以只创建一次该类的实例，从而降低系统开销。
通过以上的分析，我们可以大致总结出单例模式（singleton）的几个特点：
1，全局的，所以要用stat ic修饰
2，私有的构造方法和私有的类对象，这样确保外部类没法通过new一个对象或者直接调用类对象
3，暴露一个公共的成员方法，供外部类调用
我们说，无论什么样的单例模式，都需要结合实际的情况来设计。所以就产生了很多单例模式的实现方法，大概有以下几种：
1，懒汉式单例模式
2，饿汉式单例模式
3，线程安全的单例模式
4，静态内部类单例模式
5，枚举单例模式
1，懒汉式单例模式
懒汉式单例模式可以实现对象的延迟加载，减少系统负载。按照这几个要点，我们可以设计这样的一个类SingleTon
public class SingleTon {
/**
* 设计一个类实现singleton模式
*
* 三个要点：
* 1，全局的，所以要用static关键字修饰
* 2，私有的构造方法和私有的类对象，这样确保外部类没法通过new一个对象或者直接调用类对象
* 3，暴露一个公共的成员方法，供外部类调用
*
*/
//1，私有的构造方法
private SingleTon(){
}
//2，私有的、静态 的类对象
private static SingleTon singleTonInstance = null;
//3，暴露一个公共的成员方法，供外部类调用
public static SingleTon getSingleTonInstance(){
//判断是否创建了实例
if(singleTonInstance == null){
//创建实例
singleTonInstance = new SingleTon();
}
return singleTonInstance;
}
}
作为对比，我们再写一个普通的java类：
<span style="font-size:14px;">public class NotSingleTon {
//1，作为对比，这里把构造方法，改成公共的
public NotSingleTon(){
}
}</span>
然后我们来测试一下：
<span style="font-size:14px;">package com.java.test;
public class SingleTonTest {
/**
* @param args
*/
public static void main(String[] args) {
//单例模式测试
//static类型的成员方法是属于类的，所以建议使用直接使用类名调用
SingleTon singleTonInstance_1 = SingleTon.getSingleTonInstance();
SingleTon singleTonInstance_2 = SingleTon.getSingleTonInstance();
//测试输出
System.out.println("singleTonInstance_1.hashCode() = " + singleTonInstance_1.hashCode());
System.out.println("singleTonInstance_2.hashCode() = " + singleTonInstance_2.hashCode());
//非单例模式测试
NotSingleTon notsingleTonInstance_1 = new NotSingleTon();
NotSingleTon notsingleTonInstance_2 = new NotSingleTon();
//测试输出
System.out.println("notsingleTonInstance_1.hashCode() = " + notsingleTonInstance_1.hashCode());
System.out.println("notsingleTonInstance_2.hashCode() = " + notsingleTonInstance_2.hashCode());
}
}
</span>
打印台输出结果：
<span style="font-size:14px;">singleTonInstance_1.hashCode() = 29115481 singleTonInstance_2.hashCode() = 29115481 notsingleTonInstance_1.hashCode() = 4872882 notsingleTonInstance_2.hashCode() = 25724761 </span>
上面这个写法，是懒汉式单例模式。优点是可以实现对象的延迟加载，减少系统开销。缺点是存在线程安全问题，如果在多线程环境下，可能重复创建对象。
2，饿汉式单例模式
下面我们来看一下饿汉式单例模式：
public class SingleTon {
//1，私有的构造方法
private SingleTon(){
}
//2，全局的类对象
private static SingleTon singleTonInstance = new SingleTon();
//3，暴露一个公共的成员方法，供外部类调用
public static SingleTon getSingleTonInstance(){
return singleTonInstance;
}
}
这就是我们通常所说的饿汉式单例模式，在首次加载实例时，就创建实例的对象，而不管实际是否需要马上创建这个对象。
3，线程安全的单例模式
在多线程环境下，线程安全是一个必须要考虑的问题。
public class SingleTon {
<pre name="code" class="java" style="font-size: 14px;"> //<span style="font-family: Arial, Helvetica, sans-serif;">私有的构造方法</span>
private SingleTon(){
}
//私有的、静态的、volatile的SingleTon对象
private static volatile SingleTon singleTonInstance = null;
public static SingleTon getSingleTonInstance(){
if(singleTonInstance == null){
synchronized (SingleTon.class){
if(singleTonInstance == null){
singleTonInstance = new SingleTon();
}
}
}
return singleTonInstance;
}
}
4，静态内部类单例模式
我们知道，静态内部类只会被加载一次，所以是线程安全的。
public class SingleTon {
//静态内部类
private static class Holder {
private static SingleTon singleTonInstance = new SingleTon();
}
//私有的构造方法
private SingleTon(){
}
public static SingleTon getSingleTonInstance(){
return Holder.singleTonInstance;
}
}
上面这4种方法，实现的单例模式，都有一个共同的缺陷，就是无法避免java的反射机制，创建新的对象。而只有枚举类，才能避免反射机制创建新的的对象。
好了，今天暂时聊到这里，改天再叙。