23种设计模式 _ 单例模式
单例模式是我们最常遇到的设计模式之一,对于Java程序员来说,对于单例模式是十分常见了。
因为在spring的框架中,大量的单例模式设计思想被应用。
下面我们来看一下单例模式的几种实现方法:
根据上面的代码我们可以看到,实现单例模式的方式十分多,
其中最经典的莫过于饿汉式和懒汉式,这两种方式其实在单线程下已经可以基本可以满足开发的需求了。
但是在多线程环境下,我们就要考虑到线程的安全问题:即是否有不同的线程分别new一个对象实例,导致
不同线程创建的class类的实例不是同一个。
饿汉式
通过代码我们可以知道饿汉式已经是一个非常好的一种解决方式了。
因为根据JVM原来可以,class类在被加载到内存的jvm虚拟机中,只会初始化一次静态变量。
这就在jvm层面保证class的实例只会有一个。
因为在class类加载到jvm时,class类的静态变量就已经初始化了;
所以在运行过程中,Mgr01类的INSTANCE已经被初始化,所以不论有多少线程通过getInstance方法来获取实例,都是静态变量初始化到jvm中的那一个
但是饿汉式的缺点也是这样产生的,因为在class类加载到jvm时,class类的静态变量INSTACNE就已经初始化。
所以在java的运行状态下,如果你不使用,这就造成了资源浪费。
public class Mgr01 {
private static final Mgr01 INSTANCE = new Mgr01();
private Mgr01(){
}
public static Mgr01 getInstance(){
return INSTANCE;
}
public void m(){
System.out.println("");
}
public static void main(String[] args) {
Mgr01 m1 = Mgr01.getInstance();
Mgr01 m2 = Mgr01.getInstance();
System.out.println(m1 == m2);
}
}
懒汉式
懒汉式主要是解决饿汉式的资源浪费问题,但是这也造成了在多线程环境下,线程的安全问题:即可能new了多个Mgr03类的实例变量。
因为在INSTANCE == null时,就new Mgr03()
但是会出现一个状态,在线程较多的时候,多个线程同时运行到代码的这个位置,那么他们就会同时进入代码块,new Mgr03实例变量,
这就导致不同线程得到的INSTANCE可能不一样。
public class Mgr03 {
private static Mgr03 INSTANCE;
private Mgr03(){
}
public static Mgr03 getInstance(){
if(INSTANCE == null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr03();
}
return INSTANCE;
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) {
/* Mgr03 m1 = Mgr03.getInstance();
Mgr03 m2 = Mgr03.getInstance();
System.out.println(m1 == m2);*/
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(Mgr03.getInstance().hashCode());
}).start();
}
}
}
Double Check Lock(DCL):
为了解决懒汉式多个线程同时进入INSTANCE == null的代码块,导致new了多个类的实例变量
一个新的方法被提出,使用synchronize加锁,以此来保证多线程下的线程安全问题。这种方法确实可以,
但是我们也应当知道synchronize锁是要消耗资源了,所以直接用synchronize锁锁住getInstance方法的话,
每个线程来的时候都会额外造成synchronize锁带来的资源消耗问题。
所以聪明的程序员就又提出了DCL(双重检测锁)
我们不把synchronize锁加到getInstance方法上面,而是加到INSTANCE == null这个if判断的代码块上面,然后再在里面加上INSTANCE == null的判断
第一个if判断,是为了节省synchronize锁带来的额外资源消耗,保证一旦INSTANCE已经被实例化,后面的线程就不用再new 类的实例了。
而第二个if判断,则是为了解决线程安全问题,因为可能会有多个线程同时运行到INSTANCE == null这行代码,这就会造成多个线程会继续执行下去,执行 INSTANCE = new Mgr06();
这还是会产生多个不同的Mgr06的INSTANCE实例。但是多加一个INSTANCE == null判断,即使有多个线程同时运行到synchronize锁这个部分,但是这个代码块只能有一个线程进入,
所以第一个线程进入后,INSTANCE被实例化,其他线程之后进入后,也无法执行INSTANCE = new Mgr06()这行代码。
public class Mgr06 {
private static Mgr06 INSTANCE;
private Mgr06(){
}
public static Mgr06 getInstance(){
if(INSTANCE == null){
synchronized (Mgr06.class){
if(INSTANCE == null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr06();
}
}
}
return INSTANCE;
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) {
/* Mgr03 m1 = Mgr03.getInstance();
Mgr03 m2 = Mgr03.getInstance();
System.out.println(m1 == m2);*/
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(Mgr06.getInstance().hashCode());
}).start();
}
}
}
静态内部类
我们已经说过饿汉式已经是一个比较完美的方法了,但是会造成资源浪费。
之后有聪明的程序员就想到了一个方法来避免这个缺点,就算在Mgr07类里面,创建一个静态内部类
一开始jvm在加载过程中,把INSTANCE加载到内存中,因为没有指定初始值,也会有类的静态代码块赋值。所以INSTANCE没有被初始化
这里我们需要了解一下静态内部类的一个特性:静态内部类是在外部类调用时才加载的,也就是说静态内部类可以在外部类加载之后,再加载到jvm中。
所以我们在静态内部类中设置一个静态变量,然后指定初始值。因为我们之前提到的类在加载过程中,静态变量只会被初始化一次,所以在jvm层面中,保证了
线程的安全性。因为静态内部类被调用之后才会加载初始化,所以就避免了资源浪费问题。
public class Mgr07 {
private static Mgr07 INSTANCE;
private Mgr07(){
}
private static class Mgr07Holder{
private final static Mgr07 INSTANCE = new Mgr07();
}
public static Mgr07 getInstance(){
return Mgr07Holder.INSTANCE;
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) {
/* Mgr03 m1 = Mgr03.getInstance();
Mgr03 m2 = Mgr03.getInstance();
System.out.println(m1 == m2);*/
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(Mgr07.getInstance().hashCode());
}).start();
}
}
}