单例模式
1、饿汉式(最简单适用)
类加载到内存中,就实例化一个单例,JVM保证线程安全;
简单适用,推荐使用;
唯一缺点,不管用到与否,类加载时就完成实例化;
(话说你不用的,你加载它干嘛)
public class Mgr01{
private static final Mgr01 INSTANCE = new Mgr01();
private Mgr01(){};
`public static Mgr01 getInstance(){
return INSTANCE ;
}
public static void main(String[] args){
Mgr01 m1 = Mgr01.getInstance();
Mgr01 m2 = Mgr01.getInstance();
System.out.println(m1 == m2);
}
}
打印结果 : true
2、懒汉式
虽然达到了需要用才初始化的目的,但带来了线程的不安全
public class Mgr02{
private static Mgr02 INSTANCE ;
private Mgr02(){};
public static Mgr02 getInstance(){
if(INSTANCE = null){
INSTANCE = new Mgr02();
}
return INSTANCE ;
}
public static void main(String[] args){
for(int i = 0 ;i<100 ;i++){
new Thread(()->{
System.out.prinln(Mgr02.getInstance.hashCode());
}).start();
}
}
}
3、lazy loading (也称懒汉式)
虽然达到了需要用才初始化的目的,但带来了线程的不安全;
可以通过synchronized 来解决不安全问题,锁定了当前对象,但也带来了效率的下降
public class Mgr03{
private static Mgr03 INSTANCE ;
private Mgr03(){};
public static synchronized Mgr03 getInstance(){ //锁定了Mgr03 的class对象
if(INSTANCE = null){
INSTANCE = new Mgr03();
}
return INSTANCE ;
}
public static void main(String[] args){
for(int i = 0 ;i<100 ;i++){
new Thread(()->{
System.out.prinln(Mgr03.getInstance.hashCode());
}).start();
}
}
}
4、静态的内部类方式(最完美的写法)
JVM保证单例(在静态内部类里面加载,只有内部才能访问,外部访问不了)
加载外部类时不会加载内部类,这样可以实现懒加载
public class Mgr04{
private Mgr04(){};
//Mgr04的持有者,在静态内部类里面初始化实例对象
public static class Mgr04Holder(){
private static final Mgr04 INSTANCE = new Mgr04();
}
public static Mgr04 getInstance(){
return Mgr04Holder.INSTANCE ;
}
public static void main(String[] args){
for(int i = 0 ;i<100 ;i++){
new Thread(()->{
System.out.prinln(Mgr04.getInstance.hashCode());
}).start();
}
}
}