单列模式：
概念：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
1、单列类只能有一个实列
2、单列类必须自己创建自己的实列
3、单列类必须提供给所有其他对象获得该实列的方法
单列模式——饿汉式：
优点：线程安全、执行效率高
缺点：类加载时就初始化，浪费内存，容易产生垃圾对象（类加载时创建了对象，又没有调用方法获取实列）
/**
* 单列模式——饿汉式
* @author ypf
*
*/
public class Singleton1 {
private static Singleton1 instance = new Singleton1();
//构造方法私有化
private Singleton1() {
}
public static Singleton1 getInstance() {return instance;
}
}
单列模式——懒汉式：
优点：第一次使用时才初始化，避免了内存浪费；
缺点：线程不安全，不支持多线程；
/**
* 单列模式——懒汉式
* @author ypf
*
*/
public class Singleton2 {
private static Singleton2 instance;
//构造方法私有化
private Singleton2() {
}
public static Singleton2 getInstance() {
if(instance == null) {
instance = new Singleton2();
}
return instance;
}
}
单列模式——懒汉式（简单优化）：
优点：实现了lazy-load（懒加载），第一次使用时才初始化，避免了内存浪费，线程安全；
缺点：执行效率低
/** * 单列模式——懒汉式(简单优化) * @author ypf * */ public class Singleton3 { private static Singleton3 instance; //构造方法私有化 private Singleton3() { }
//对方法加synchronized关键字 public synchronized static Singleton3 getInstance() { if(instance == null) { instance = new Singleton3();
}
return instance; } }
单列模式——双重检测锁式：
优点：第一次使用时才初始化，避免了内存浪费，线程安全，在多线程情况下也能保持高性能；
缺点 : 实现较复杂
在本次线程内，当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后再取变量值时，就直接从寄存器中取值；
/**
* 单列模式——双重检测锁式
* @author ypf
*
*/
public class Singleton4 {
//给变量加volatile关键字，为了让编译器在使用这个变量时必须每次都重新读取这个变量的值，而不是使用保存在寄存器里的备份
private static volatile Singleton4 instance;
//构造方法私有化
private Singleton4() {
}
public synchronized static Singleton4 getInstance() {
//避免每次都获取锁
if(instance == null) {
synchronized (Singleton4.class) {
if(instance == null) {
instance = new Singleton4();
}
}
}
return instance;
}
}
单列模式——静态内部类式：
优点：线程安全、延迟加载、可以达到与双重检测锁一样的效果，但实现更简单，这种方式只适用于静态域的情况。
/**
* 单列模式——静态内部类
* @author ypf
*
*/
public class Singleton5 {
private static class getSingleton{
private static final Singleton5 INSTANCE = new Singleton5();
}
//构造方法私有化
private Singleton5() {
}
public static Singleton5 getInstance() {
return getSingleton.INSTANCE;
}
}
单列模式——枚举式：
优点：避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。
刚开始看到枚举式是这样的，
/**
* 单列模式——枚举
* @author ypf
*
*/
public enum Singleton6 {
INSTANCE;
public void anyMethod(){
}
}
测试一下：
/**
* 单列模式——枚举
* @author ypf
*
*/
public enum Singleton6 {
INSTANCE;
private Singleton6() {
System.out.println("构造方法");
}
public void anyMethod(){
System.out.println(123);
}
}
测试代码：
public class TestSingleton {
public static void main(String[] args) {
Singleton6 instance = Singleton6.INSTANCE;
Singleton6 instance1 = Singleton6.INSTANCE;
Singleton6 instance2 = Singleton6.INSTANCE;
Singleton6 instance3 = Singleton6.INSTANCE;
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
System.out.println(instance2.hashCode());
instance.anyMethod();
instance1.anyMethod();
instance2.anyMethod();
instance3.anyMethod();
}
}
效果展示：
可以看到构造方法只执行了一次，即是同一个实列