单例模式
定义
所谓单例,就是整个程序某个类有且仅有一个实例。该类负责创建自己的对象,同时确保只有一个对象被创建。
特点
- 类构造器私有
- 持有自己类型的私有属性
- 对外提供获得实例的静态方法
几种类型
饿汉式
- 类加载到内存后,就实例化一个单例,jvm保证线程安全
- 优点: 简单易用,
- 缺点:不管用到与否,类装载时就完成实例化,可能会造成资源的浪费
/**
* 饿汉模式
* @author manzuo
* @date 2020/6/4 16:04
*/
public class Singleton1 {
/*持有自己类型的私有属性*/
private static final Singleton1 INSTANCE = new Singleton1();
/*类构造器私有*/
private Singleton1(){};
/*对外提供获得实例的静态方法*/
public static Singleton1 getInstance(){
return INSTANCE;
}
public static void main(String[] args) {
Singleton1 s1 =Singleton1.getInstance();
Singleton1 s2 =Singleton1.getInstance();
System.out.println(s1==s2);
}
}
懒汉式
- 优点:用到的时候才会加载
- 缺点:多线程的情况下不安全
/**
* lazy loading
* 懒汉式
*
* @author manzuo
* @date 2020/6/4 22:53
*/
public class Singleton2 {
private static Singleton2 INSTANCE;
private Singleton2(){};
public static Singleton2 getInstance(){
if (INSTANCE == null){
INSTANCE = new Singleton2();
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()-> System.out.println(Singleton2.getInstance().hashCode())).start();
}
}
}
- 为了解决线程安全做出的改进,通过双重检测锁模式保证了多线程下也只存在一个单例.
public class Singleton2 {
private static volatile Singleton2 INSTANCE;
private Singleton2(){};
public static Singleton2 getInstance(){
if (INSTANCE == null){
//可以通过synchronized解决线程安全问题
synchronized (Singleton2.class){
if (INSTANCE==null){
INSTANCE = new Singleton2();
}
}
}
return INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()-> System.out.println(Singleton2.getInstance().hashCode())).start();
}
}
}
- 但是双重检测锁模式也不是绝对安全的,可以通过反射来破坏.
import java.lang.reflect.Constructor;
public class Singleton2 {
private static volatile Singleton2 INSTANCE;
private Singleton2(){};
//DCL 懒汉式
public static Singleton2 getInstance(){
if (INSTANCE == null){
//可以通过synchronized解决线程安全问题
synchronized (Singleton2.class){
if (INSTANCE==null){
INSTANCE = new Singleton2();
}
}
}
return INSTANCE;
}
public static void main(String[] args) throws Exception {
//通过反射可以破坏DCL(双重锁检测)懒汉式 单例模式
Class c1 = Singleton2.class;
//获取默认无参构造器
Constructor declaredConstructor = c1.getDeclaredConstructor();
//关闭安全检测,以便访问私有构造器
declaredConstructor.setAccessible(true);
//生成实例
Singleton2 instance = (Singleton2) declaredConstructor.newInstance();
Singleton2 instance1 =(Singleton2)declaredConstructor.newInstance();
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
}
}
静态内部类方式
- JVM保证了单例以及线程安全
- 加载外部类的时候不会加载内部类,实现了懒加载
- 但还是会被反射给破坏(通过反射调用私有的构造方法)
/**
*
* @author manzuo
* @date 2020/6/5 1:34
*/
public class Singleton3 {
private Singleton3(){}
private static class Singleton3Inner{
private final static Singleton3 INSTANCE = new Singleton3();
}
public static Singleton3 getInstance(){
return Singleton3Inner.INSTANCE;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()-> System.out.println(Singleton3.getInstance().hashCode())).start();
}
}
}
枚举单例
- enum本身也是一个Class类,不仅可以解决线程安全问题,也可以防止反序列化,而且还可以防止反射破坏单例
/**
* 出自《Effective Java》
* 不仅可以解决线程安全问题,也可以防止反序列化
* @author manzuo
* @date 2020/6/5 1:45
*/
public enum Singleton4 {
INSTANCE;
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()-> System.out.println(Singleton4.INSTANCE.hashCode())).start();
}
}
}