单例模式就是存在一个实例。这个实例在整个应用中只存在一个。接下来我就演示下几种常见的单例：
1 饿汉模式
饿汉模式就是类一加载，该实例就创建了，
public class SingleSimple {
/**
* private代表是不向外部暴露出去，
*/
private static SingleSimple single=new SingleSimple();
private SingleSimple(){}//private代表不能new创建该实例。必须为private
public static SingleSimple newInstance(){
return single;
}
}
这就是一个简单的饿汉单例。
然后测试下：
public class SingleSimpleTest {
public static void main(String[] args) {
SingleSimple single01=SingleSimple.newInstance();
SingleSimple single02=SingleSimple.newInstance();
System.out.println(single01==single02);
}
}
运行结果：
可以看到，运行结果为true，这就说明single01和single02是指向内存中同一个。
2 懒汉模式（线程不安全）
懒汉模式是根据调用者是不是想要个实例，要的话就创建一个，不要的话就不创建。
public class SingleSimple {
/**
* private代表是不向外部暴露出去，
*/
private static SingleSimple single=null;
private SingleSimple(){}//private代表不能new创建该实例。
public static SingleSimple newInstance(){
if (single==null) {
single=new SingleSimple();
}
return single;
}
}
这是一个超级简单的懒汉单例。
测试：
public class SingleSimpleTest {
public static void main(String[] args) {
SingleSimple single01=SingleSimple.newInstance();
SingleSimple single02=SingleSimple.newInstance();
System.out.println(single01==single02);
}
}运行结果：
还是为true说明我们写的懒汉单例没问题。
2 懒汉模式（线程安全）
懒汉模式是根据调用者是不是想要个实例，要的话就创建一个，不要的话就不创建。
public class SingleSimple {
/**
* private代表是不向外部暴露出去，
*/
private static SingleSimple single=null;
private SingleSimple(){}//private代表不能new创建该实例。
public static synchronized SingleSimple newInstance(){
if (single==null) {
single=new SingleSimple();
}
return single;
}
}
这是一个超级简单的懒汉单例。只是加了个同步
测试：
public class SingleSimpleTest {
public static void main(String[] args) {
SingleSimple single01=SingleSimple.newInstance();
SingleSimple single02=SingleSimple.newInstance();
System.out.println(single01==single02);
}
}运行结果：
还是为true说明我们写的懒汉单例没问题。
4, 饿汉单例变形（静态代码块）。
静态代码块实现，静态代码块也是随着类加载的。只加载一次
public class SingleSimple {
/**
* private代表是不向外部暴露出去，
*/
private static SingleSimple single=null;
private SingleSimple(){}//private代表不能new创建该实例。
static{
single=new SingleSimple();
}
public static SingleSimple newInstance(){
return single;
}
}
测试代码：
public class SingleSimpleTest {
public static SingleSimple single01=null;
public static SingleSimple single02=null;
public static void main(String[] args) {
single01=SingleSimple.newInstance();
single02=SingleSimple.newInstance();
System.out.println(single01==single02);
System.out.println(single02);
System.out.println(single01);
}
}也为true ，说明这也是一种单例。
5， 静态内部类
public class SingleSimple {
private SingleSimple(){}//private代表不能new创建该实例。
static class InnerClass{
private static SingleSimple single=new SingleSimple();
}
public static SingleSimple newInstance(){
return InnerClass.single;
}
}测试代码一样。不贴出来了：
运行结果：
还是为true,说明也是单例。
6 ， 双重判断。
public class SingleSimple {
/**
* private代表是不向外部暴露出去，
* volatile关键字是代表可见性
*/
private static volatile SingleSimple single=null;
private SingleSimple(){}//private代表不能new创建该实例。
public static SingleSimple newInstance(){
if (single==null) {
synchronized (SingleSimple.class) {
if (single==null) {
single=new SingleSimple();
}
}
}
return single;
}
}
在第二个判断时，加了锁，线程是安全的。比第三种实现方式更安全。
测试代码一样，不贴出来了。
运行结果：
为true就说明单例是成功的。
7 ， 枚举实现
枚举是java1.5才出现的。它也可以实现单例
public enum SingleSimple {
SINGLE;
}
测试代码：
public class SingleSimpleTest {
public static void main(String[] args) {
SingleSimple S1=SingleSimple.SINGLE;
SingleSimple S2=SingleSimple.SINGLE;
System.out.println(S1==S2);
System.out.println(S1);
System.out.println(S2);
}
}运行结果：
为true说明单例成功了。如果不明白枚举的可以去看看。枚举其实挺重要的。
下面我就简单演示下怎么用枚举吧 ：
首先是用enum声明的，就这样
public enum SingleSimple {
SINGLE01,SINGLE02,SINGLE03;
public void methodInEnum(){
System.out.println("我是来自枚举中的方法。。。");
}
}
然后就演示下怎么用枚举。
public class SingleSimpleTest {
public static void main(String[] args) {
SingleSimple s1=SingleSimple.SINGLE01;
SingleSimple s2=SingleSimple.SINGLE02;
SingleSimple s3=SingleSimple.SINGLE03;
s1.methodInEnum();//调用枚举中的方法
int position01=s1.ordinal();//返回的是第几个位置
int position02=s2.ordinal();//返回的是第几个位置
int position03=s3.ordinal();//返回的是第几个位置
System.out.println("SINGLE01的位置"+position01);
System.out.println("SINGLE02的位置"+position02);
System.out.println("SINGLE03的位置"+position03);
System.out.println(s1.compareTo(s2));//比较的是位置的大小
SingleSimple all[]= s1.values();//返回的是SINGLE01，SINGLE02，SINGLE03
/**
* 全部打印出来
*/
for (int i = 0; i <all.length; i++) {
System.out.println(all[i].name());
}
}
}运行结果：
其实枚举也没什么难度，只有几个方法。我差不多都演示了。
总结：
单例模式我写了七种，目的就是一个，就是在整个应用中只存在一个实例。双重判断现在是用的最多的单例。
最后补充一句：其实反射可以创建实例。即使是构造方法被private修饰，也可以创建一个新实例，但是这样就不能构成单例。反射不会的，应该要加强了。哈哈。。。
作者：song_shui_lin 发表于2016/10/3 13:23:23 原文链接
阅读：208 评论：4 查看评论
，共同进步嘛！