前言
以前我自认为对设计模式较为熟悉了，最起码最简单的单例模式应该已经很会了。可是，我真的会了吗？书只会越读越薄，每一次的回顾都带来新的发现。
第一种写法
这是最简单的一种写法，简单实用，推荐使用！
public class Mgr01 {
private static final Mgr01 INSTANCE = new Mgr01();
private Mgr01(){};
public static Mgr01 getInstance(){
return INSTANCE;
}
public void m(){
System.out.println("m");
}
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 void m(){
System.out.println("m");
}
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){
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){
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();
}
}
}
第五种写法
对于上面的第四种写法，妄图通过减少同步代码块的方式见提高效率，然后不可行。
public class Mgr05 {
private static Mgr05 INSTANCE;
private Mgr05(){};
public static Mgr05 getInstance(){
if (INSTANCE == null){
synchronized(Mgr05.class){
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();
}
}
}
第六种写法
在以前，这种写法是完美的一种写法，采用双重if判断。
public class Mgr06 {
private static Mgr06 INSTANCE;
private Mgr06(){
}
public static Mgr06 getInstance(){
if (INSTANCE == null){
synchronized (Mgr06.class){
if (INSTANCE == null){
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();
}
}
}
第七种写法
其实上面的第六种写法还不够完美，有一点小瑕疵，第七种写法采用了静态内部类方式，由JVM保证单例。这是最完美的两种写法之一，为什么说是之一，因为第八种也是最完美的写法之一。
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(Mgr06.getInstance().hashCode());
}).start();
}
}
}
第八种写法
这种写法出自《Effective Java》一书，作者亲自写出了一种最简单也最明了的写法，采用了枚举单例，这是八种写法中唯一一种可以避免反序列化的写法。同时也解决了线程同步。
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();
}
}
}
