最近重新复习了下设计模式,发现这好像不是我所了解的设计模式。 今天把它记录下来，以便以后查阅学习。
饿汉式
package com.example.demo.pojo;
public class SingletonDemo1 {
private static final SingletonDemo1 SINGLETON = new SingletonDemo1();
private SingletonDemo1(){
}
public static SingletonDemo1 getInstance(){
return SINGLETON;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->
System.out.println(getInstance())
).start();
}
}
}
该写法可在实际当中使用，唯一的缺点就是非 lazy loading 。
饿汉式之静态内部类：
package com.example.demo.pojo;
public class SingletonDemo4 {
private SingletonDemo4(){
}
//静态内部类
private static class SingleHolder{
private static final SingletonDemo4 SINGLETON = new SingletonDemo4();
public static SingletonDemo4 getInstance(){
return SINGLETON;
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->
System.out.println(SingleHolder.getInstance())
).start();
}
}
}
静态内部类算是第一种的升级版，大家不妨试试这种写法。
懒汉式
package com.example.demo.pojo;
public class SingletonDemo2 {
private static SingletonDemo2 SINGLETON ;
private SingletonDemo2(){
}
public static synchronized SingletonDemo2 getInstance() {
if(SINGLETON==null){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
SINGLETON = new SingletonDemo2();
}
return SINGLETON;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->
System.out.println(getInstance())
).start();
}
}
}
虽然解决了多线程的问题，但是效率会明显下降，对于有追求的程序员来说，这是不可忍受的。
懒汉式之双重检查
package com.example.demo.pojo;
public class SingletonDemo3 {
//添加volatile 解决指令重排发送的问题
private static volatile SingletonDemo3 SINGLETON ;
private SingletonDemo3(){
}
public static SingletonDemo3 getInstance() {
if(SINGLETON==null){//第一次判断如果已经实例化了,直接return.
synchronized (SingletonDemo3.class){
if(SINGLETON==null){//第二次判断是解决多线程问题
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
SINGLETON = new SingletonDemo3();
}
}
}
return SINGLETON;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->
System.out.println(getInstance())
).start();
}
}
}
以上的几种虽然说可以解决单例的问题,但是却不能防止反序列化的问题。
为此，《Effective Java》的作者 约书亚·布洛克（Joshua Bloch）。在此书中，为我们提供一种解决方案。
枚举式
package com.example.demo.pojo;
public enum SingletonDemo5 {
SINGLETON;
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->
System.out.println(SINGLETON.hashCode())
).start();
}
}
}
最后一种，有人说是完美的，但是追求完美的程序员来说，完美，永远是下一种。 如果是实际开发中，对于普通的我们来说，还是使用第一和第二种。 好了，单例模式我们就聊到这里，本人水平有限，如有错误，还请诸位帮忙斧正。
