1、简单介绍
单例模式是一种创建型设计模式, 让你能够保证一个类只有一个实例, 并提供一个访问该实例的全局节点。
在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例
2、单例模式特点
1.单例类只有一个实例
2.单例类必须自己创建自己得唯一实例
3.单例类必须给所有其他对象提供这一实例
3、分类
饿汉式,懒汉式,双重检测锁式,静态内部类式,枚举类单例等,只要常见得是前三种
饿汉模式
解释:饿汉模式,实例在初始化得时候就创建好,不管你用不用
优点:线程安全,在类加载得同时创建好一个静态类
缺点:占一定内存,消耗资源
代码:
/**
* @Author charles.yao
* @Description 饿汉式单例模式
* @Date 2023/2/23 18:50
*/
public class HungerySingleton {
//私有实例,静态变量在类加载得时候进行初始化,线程安全
private static final HungerySingleton INSTANCE = new HungerySingleton();
public HungerySingleton() {
}
/**
* 获取实例得方法-静态工厂方法
*
* @return
*/
public static HungerySingleton getInstance() {
return INSTANCE;
}
}
/**
* @Author charles.yao
* @Description 饿汉测试类
* @Date 2023/2/23 18:52
*/
public class HungeryTest {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
System.out.println("饿汉创建实例" + HungerySingleton.getInstance());
}
}
}
懒汉模式(线程不安全方式)
解释:懒汉模式,只有在用的时候才去检查有没有实例,有直接返回,没有创建实例
优点:起到懒加载模式,不占用资源,
缺点:在多线程模式下,会有线程安全问题,if (lazySingelton1 == null),会产生多个实例,
/**
* @Author charles.yao
* @Description 懒汉模式第一种
* @Date 2023/2/23 19:00
*/
public class LazySingelton1 {
public LazySingelton1() {
}
private static LazySingelton1 lazySingelton1 = null;
public static LazySingelton1 getInstance() {
if (lazySingelton1 == null) {
lazySingelton1 = new LazySingelton1();
}
return lazySingelton1;
}
}
/**
* @Author charles.yao
* @Description 懒汉模式测试类
* @Date 2023/2/23 19:02
*/
public class LazySIngleTest {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(LazySingelton1.getInstance());
}).start();
}
}
}
测试结果显示产生多个实例
com.yyh.designpattern.singetonPattern.lazy.LazySingelton1@371adbca
com.yyh.designpattern.singetonPattern.lazy.LazySingelton1@371adbca
com.yyh.designpattern.singetonPattern.lazy.LazySingelton1@371adbca
com.yyh.designpattern.singetonPattern.lazy.LazySingelton1@371adbcc
懒汉模式(线程安全方式)
方法加锁,使用synchronized,解决线程安全问题,但是每次调动都加锁,效率低
/**
* @Author charles.yao
* @Description 懒汉模式第2种-线程安全模式
* @Date 2023/2/23 19:00
*/
public class LazySingelton2 {
public LazySingelton2() {
}
private static LazySingelton2 lazySingelton1 = null;
public static synchronized LazySingelton2 getInstance() {
if (lazySingelton1 == null) {
lazySingelton1 = new LazySingelton2();
}
return lazySingelton1;
}
}
懒汉模式(双重检锁模式)
进入getInstance方法时先不同步,进入方法过后,先检查实例是否存在,如果存在则直接返回,如果不存在才进入synchronized修饰的同步代码块,进入后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例。即保证了懒加载,又保证了高性能。推荐使用。
双重检查加锁机制的实现使用到一个关键字volatile:被volatile修饰的变量的值,保证了多个线程之间的可见性。即被一个线程修改后,其他线程立即可见。
/**
* @Author charles.yao
* @Description 懒汉模式第3种--双重检查锁定-线程安全,性能较低
* @Date 2023/2/23 19:00
*/
public class LazySingelton3 {
public LazySingelton3() {
}
private static volatile LazySingelton3 lazySingelton1 = null;
public static synchronized LazySingelton3 getInstance() {
//第一个 if 语句用来避免 uniqueInstance 已经被实例化之后的加锁操作
if (lazySingelton1 == null) {
synchronized (LazySingelton3.class) {
//第二个 if 语句进行了加锁,所以只能有一个线程进入,就不会出现 instance == null 时两个线程同时进行实例化操作。
if (lazySingelton1 == null)
lazySingelton1 = new LazySingelton3();
}
}
return lazySingelton1;
}
}
静态内部类
线程安全但是破坏了反射
/**
* @Author charles.yao
* @Description 静态内部类单例模式-线程安全可能会破坏反射
* @Date 2023/2/23 19:22
*/
public class StaticInnerClassSingleton {
//静态内部类
private static class LoadingClass {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
/**
* 生成方法
*
* @return
*/
public static StaticInnerClassSingleton getInstance() {
return LoadingClass.INSTANCE;
}
}