单例模式
- 确保全局之多一个对象
- 用于构造缓慢的对象，需要统一管理的资源
- 缺点是很多全局状态，线程安全性
/**
* 懒汉模式
* 单例的实例在第一次使用时创建
* 线程不安全
*/
public class SingletonExample1 {
//私有构造函数
private SingletonExample1(){
}
//单例对象
private static SingletonExample1 instance = null;
//静态的工厂方法
public static SingletonExample1 getInstance(){
if(instance == null){
instance = new SingletonExample1();
}
return instance;
}
}
/**
* 懒汉模式
* 单例的实例在第一次使用时创建
* 线程安全
*/
public class SingletonExample3 {
//私有构造函数
private SingletonExample3(){
}
//单例对象
private static SingletonExample3 instance = null;
//静态的工厂方法
public static synchronized SingletonExample3 getInstance(){
if(instance == null){
instance = new SingletonExample3();
}
return instance;
}
}
/**
* 懒汉模式 --- 双重同步锁单例模式
* 单例的实例在第一次使用时创建
* 线程不安全
*/
public class SingletonExample4 {
//私有构造函数
private SingletonExample4(){
}
// 1、memory = allocate() 分配内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
//JVM和cpu优化，发生了指令重排
// 1、memory = allocate() 分配内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
//单例对象
private static SingletonExample4 instance = null;
//静态的工厂方法
public static SingletonExample4 getInstance(){
if(instance == null){ //双重检测机制
synchronized(SingletonExample4.class){//同步锁
if(instance == null) {
instance = new SingletonExample4();
}
}
}
return instance;
}
}
/**
* 懒汉模式 --- 双重同步锁单例模式
* 单例的实例在第一次使用时创建
* 线程安全
*/
public class SingletonExample5 {
//私有构造函数
private SingletonExample5(){
}
// 1、memory = allocate() 分配内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
//JVM和cpu优化，发生了指令重排
// 1、memory = allocate() 分配内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
//单例对象 volatile + 双重检测机制 -> 禁止指令重排
private volatile static SingletonExample5 instance = null;
//静态的工厂方法
public static SingletonExample5 getInstance(){
if(instance == null){ //双重检测机制
synchronized(SingletonExample5.class){//同步锁
if(instance == null) {
instance = new SingletonExample5();
}
}
}
return instance;
}
}
/**
* 饿汉模式
* 单例的实例在类装载时创建
* 线程安全
*/
public class SingletonExample2 {
//私有构造函数
private SingletonExample2(){
}
//单例对象
private static SingletonExample2 instance = new SingletonExample2();
//静态的工厂方法
public static SingletonExample2 getInstance(){
return instance;
}
}
/**
* 饿汉模式
* 单例的实例在类装载时创建
* 线程安全
*/
public class SingletonExample6 {
//私有构造函数
private SingletonExample6(){
}
//单例对象
private static SingletonExample6 instance = null;
static{
instance = new SingletonExample6();
}
//静态的工厂方法
public static SingletonExample6 getInstance(){
return instance;
}
public static void main(String[] args) {
System.out.println(getInstance().hashCode());
System.out.println(getInstance().hashCode());
}
}
/**
* 枚举模式：最安全，推荐使用
* @author WangCH
* @create 2018-03-21 21:23
*/
public class SingletonExample7 {
private SingletonExample7(){
}
public static SingletonExample7 getInstance(){
return Singleton.INSTANCE.getInstance();
}
private enum Singleton{
INSTANCE;
private SingletonExample7 singletonExample7;
//JVM保证绝对只被调用1次
Singleton(){
singletonExample7 = new SingletonExample7();
}
public SingletonExample7 getInstance() {
return singletonExample7;
}
}
}
