什么是单例模式
单列模式是保证在内存之中只有一个实例
单列模式的八种写法
- 第一种写法饿汉式 类加载到内存后，就实例化一个单例，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);
}
}
- 第二种写法 饿汉式，跟第一种一样，只是放在静态代码快加载
public class Mgr02 {
private static final Mgr02 INSTANCE;
static {
INSTANCE = new Mgr02();
}
private Mgr02() {
};
public static Mgr02 getInstance() {
return INSTANCE;
}
public static void main(String[] args) {
Mgr02 m1 = Mgr02.getInstance();
Mgr02 m2 = Mgr02.getInstance();
System.out.println(m1 == m2);
}
}
- 第三种写法 懒汉式就是什么时候用的时候才初始化，虽然达到了按需初始化的目的，但却带来线程不安全的问题
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) {
for(int i=0; i<100; i++) {
new Thread(()->
System.out.println(Mgr03.getInstance().hashCode())
).start();
}
}
}
- 第四种写法,懒汉式的另一种写法synchronized解决，但也带来效率下降
public class Mgr04 {
private static Mgr04 INSTANCE;
private Mgr04() {
}
public static synchronized Mgr04 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr04();
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr04.getInstance().hashCode());
}).start();
}
}
}
- 第五种写法, 懒汉式妄图通过减小同步代码块的方式提高效率，在多线程访问情况下，不能保证只有一个Mgr05实例
public class Mgr05 {
private static Mgr05 INSTANCE;
private Mgr05() {
}
public static Mgr05 getInstance() {
if (INSTANCE == null) {
synchronized (Mgr05.class) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr05();
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr05.getInstance().hashCode());
}).start();
}
}
}
- 第六种方法 懒汉式 双重非空检查，还要加上volatile，因为在创建对象的时候，第二条指令和第三条指令会进行重排序。假设此时线程1通过第二次检查，在创建对象的过程中，第二条指令和第三条指令出现重排序，此时INSTANCE指向的是一个半初始化的对象。如果在这个时候线程2进来了，在执行第一次检查的时候发现INSTANCE并非为空，这时就直接返回了半初始化的INSTANCE，从而会出现问题。
public class Mgr06 {
private static volatile Mgr06 INSTANCE; //JIT
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) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr06.getInstance().hashCode());
}).start();
}
}
}
- 第七种方法 静态内部类写法，加载外部类时不会加载内部类，这样可以实现懒加载
public class Mgr07 {
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) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr07.getInstance().hashCode());
}).start();
}
}
}
- 第八种写法，枚举单例不仅可以解决线程同步。还可以防止反序列化，最完美的写法，枚举类没有办法反序列化，是因为枚举类没有构造方法，所以没办法反序列化
public enum Mgr08 {
INSTANCE;
public void m() {}
public static void main(String[] args) {
for(int i=0; i<100; i++) {
new Thread(()->{
System.out.println(Mgr08.INSTANCE.hashCode());
}).start();
}
}
}