``23种设计模式之单例模式(8种写法)
/**
* 饿汉式
* <p>
* 高效 没有线程安全问题 简单
* <p>
* jvm保证线程安全问题
*/
public class Merge01 {
private static final Merge01 test = new Merge01();
private Merge01() {
}
public static Merge01 getInstance() {
return test;
}
public static void main(String[] args) {
Merge01 test001 = Merge01.getInstance();
Merge01 test002 = Merge01.getInstance();
System.out.println(test002 == test002);
}
}
/**
* 用静态块初始化
*/
public class Merge02 {
private static final Merge02 INSTANCE;
static {
INSTANCE = new Merge02();
}
private Merge02() {
}
;
public static Merge02 getInstance() {
return INSTANCE;
}
;
public static void main(String[] args) {
Merge02 test001 = Merge02.getInstance();
Merge02 test002 = Merge02.getInstance();
System.out.println(test002 == test002);
}
}
/**
* 懒汉式
* 懒加载模式 lazy-loading
* 做到了按需初始化,但是多线程访问时有线程安全问题
*/
public class Merge03 {
private static Merge03 INSTANCE;
private Merge03() {
}
;
public static Merge03 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Merge03();
}
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(Merge03.getInstance().hashCode());
}).start();
}
}
}
/**
* 懒加载模式 lazy-loading 加锁避免了线程安全问题,但是效率受影响
*/
public class Merge04 {
private static Merge04 INSTANCE;
private Merge04() {
}
;
public static synchronized Merge04 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Merge04();
}
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(Merge04.getInstance().hashCode());
}).start();
}
}
}
/**
* 懒加载模式 lazy-loading
* instance == null 和sychnorized方法没有同步,线程安全问题存在、
*/
public class Merge05 {
private static Merge05 INSTANCE;
private Merge05() {
}
;
public static Merge05 getInstance() {
if (INSTANCE == null) {
synchronized (Merge05.class) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Merge05();
}
}
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(Merge05.getInstance().hashCode());
}).start();
}
}
}
/**
* 懒加载模式 lazy-loading
* 双重检查,接近完美
*/
public class Merge06 {
private static
Merge06 INSTANCE;
private Merge06() {
}
;
public static Merge06 getInstance() {
if (INSTANCE == null) {
synchronized (Merge06.class) {
if (INSTANCE == null) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
INSTANCE = new Merge06();
}
}
}
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(Merge06.getInstance().hashCode());
}).start();
}
}
}
/**
* 懒加载模式 lazy-loading
* <p>
* 静态内部类方式,jvm保证线程安全问题,
* <p>
* Merge07Holder在调用getInstance()时才被实例一次,所以INSTANCE实例也只被实例一次,几乎完美的方式
*/
public class Merge07 {
private Merge07() {
}
;
private static class Merge07Holder {
private static final Merge07 INSTANCE = new Merge07();
}
public static Merge07 getInstance() {
return Merge07Holder.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(Merge07.getInstance().hashCode());
}).start();
}
}
}
/**
* 枚举类写法
* 解决线程安全问题,同时方式反序列化
*/
public enum Merge08 {
INSTANCE;
public void m() {
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() -> {
System.out.println(Merge08.INSTANCE.hashCode());
}).start();
}
}
}