设计模式 - java代码实现单例模式

常见的单例模式的实现有五种，其中一种是饿汉式，四种是懒汉式。

1.饿汉式：不存在线程安全问题。但不管使不使都会占用内存空间，造成内存利用率降低。

package com.zx.singleton;

public class Singleton1 {

private Singleton1(){};

private static Singleton1 instance=new Singleton1();

public static Singleton1 getInstance(){
return instance;
}

}

2.懒汉式的第一种：最简单，存在线程安全问题，不使用。

package com.zx.singleton;

public class Singleton2 {

private Singleton2(){};

private static Singleton2 instance;

public static Singleton2 getInstance(){
if(instance==null){
instance=new Singleton2();
}
return instance;
}
}

3.懒汉式的第二种：解决了线程安全问题。其中volatile防止重排序，Sychroniezd加锁。但存在的问题是Sychroniezd加在整个方法上导致运行效率较低。

package com.zx.singleton;

public class Singleton3 {

private Singleton3(){};

private static volatile Singleton3 instance;

public static synchronized Singleton3 getInstance(){
if(instance==null){
instance=new Singleton3();
}
return instance;
}
}

4.懒汉式的第三种：不存在线程安全问题。解决了上一种的问题。存在的问题就是加锁降低效率。

package com.zx.singleton;

public class Singleton4 {

private Singleton4(){};

private static volatile Singleton4 instance;

public static Singleton4 getInstance(){
if(instance==null){
synchronized (Singleton4.class) {
if(instance==null){
instance=new Singleton4();
}
}
}
return instance;
}
}

懒汉式的第四种：使用静态内部类，解决线程安全问题，同时不使用锁提高效率。

内部类时延时加载的，也就是在第一次使用时才加载，不使用就不加载，所以可以很好的实现懒汉式单例模式。

package com.zx.singleton;

public class Singleton5 {

private Singleton5(){};

private static class Sub{
private final static Singleton5 instance=new Singleton5();
}

public static Singleton5 getInstance(){
return Sub.instance;
}
}

单例虽小，五脏俱全。