文章目录
简介
单例模式：这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式
实现单例模式需要以下几点：
- 私有化实例变量。
- 私有化构造器。
- 提供一个获取实例的静态方法。
饿汉式
/**
* 饿汉式
* 类加载到内存后，被实例化一个单例，JVM保证线程安全
* 简单实用 推荐实用，
* 唯一缺点：不管用不用，类装载是都完成实例化
*/
public class Singleton01 {
private static final Singleton01 INSTANCE = new Singleton01();
private Singleton01(){}
private static Singleton01 getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
Singleton01 s1 = Singleton01.getInstance();
Singleton01 s2 = Singleton01.getInstance();
System.out.println(s1 ==s2);
}
}
懒汉式
/**
* 懒汉式
*/
public class Singleton02 {
private static Singleton02 INSTANCE;
private Singleton02(){}
public static Singleton02 getInstance(){
if(INSTANCE == null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton02();
}
return INSTANCE;
}
}
懒汉式线程安全
/**
* 懒汉式
*/
public class Singleton03 {
private static Singleton03 INSTANCE;
private Singleton03(){}
//线程安全6
public static synchronized Singleton03 getInstance(){
if(INSTANCE == null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton03();
}
return INSTANCE;
}
}
懒汉式线程安全另外写法
/**
* 懒汉式
*/
public class Singleton04 {
private static Singleton04 INSTANCE;
private Singleton04(){}
//线程安全6
public static Singleton04 getInstance(){
if(INSTANCE == null){
synchronized (Singleton04.class) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton04();
}
}
return INSTANCE;
}
}
懒汉式 双端检索模式
/**
* 懒汉式
* 可以通过synchronized 解决，但是也带来了效率下降
*/
public class Singleton05 {
private static volatile Singleton05 INSTANCE;
private Singleton05(){}
//线程安全6
public static Singleton05 getInstance(){
if(INSTANCE == null){
synchronized (Singleton05.class) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton05();
}
}
return INSTANCE;
}
}
总结
单例模式比较简单，保证只有一个实例就ok。
