一、饿汉式之静态常量
1.1 实现步骤
1. 私有化构造方法
2. 本类内部创建对象实例并私有化
3. 提供一个公开的静态方法返回实例对象,供外部访问
代码实现
public class Singleton implements Serializable {
//1.构造器私有化
private Singleton(){}
//2.本类内部创建对象实例
private static final Singleton instance = new Singleton();
//3.提供一个公有的静态方法,返回实例对象
public static Singleton getInstance(){
return instance;
}
private Object readResolve(){
return instance;
}
}
1.2 优缺点说明
1)优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
2)缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费。
3) 这种方式基于classloader机制避免了多线程的同步问题。不过,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到了lazy loading的效果。
4)并且这种方式对于反射和序列化都是不安全的。
反射
测试
我们可以看到通过反射获取构造方法之后我们可以new一个实例,这个实例和通过饿汉式得到的实例对象并不是同一个实例。
序列化
工具类
public class SerializeUtil {
//将当前对象序列化到一个obj的文件中
public static void serialize(Object obj) {
ObjectOutputStream output = null;
try {
File file = new File("obj");
output = new ObjectOutputStream(new FileOutputStream(file));
output.writeObject(obj);
output.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//把obj文件反序列化成一个对象
public static Object unzerialize() {
ObjectInputStream input = null;
try {
File file = new File("obj");
input = new ObjectInputStream(new FileInputStream(file));
//读取
Object object = input.readObject();
return object;
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
}
测试
可以看到,我们先把对象序列化到
obj
文件中,然后又从obj
文件中反序列化获取两个对象,这两个对象并不是同一个对象。出现这种情况的原因是静态的变量在序列化的时候是不会被保存的,那么在反序列化的时候就会重新生成实例,这样就破坏了单例。
解决序列化问题的方法是,我们在类中加一个方法,让这个方法最终返回这个实例对象。就像开始代码中的那个readResolve()方法就是解决了这种序列化的问题。
二、饿汉式之静态代码块
这种方式和第一种方式有点类似。
public class Singleton2 implements Serializable {
private Singleton2() {
}
private static Singleton2 instance;
static {
instance = new Singleton2();
}
public static Singleton2 getInstance() {
return instance;
}
}
这种方式和第一种方式有些类似,只不过把实例化的过程放在了静态代码块中,也是在类装载的时候就执行静态代码块中的代码,初始化类的实例。优缺点和第一种是一样的。
三、静态内部类
public class Singleton3 {
//私有化构造方法
private Singleton3(){}
//在静态内部类里面创建实例
private static class SingletonHolder{
private static final Singleton3 instance = new Singleton3();
}
//对外提供静态公开方法用于获取对象
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
在Singleton3装载的时候并不会装载静态内部类,只有当我们去调用getInstance()方法的时候才会去装载静态内部类,而在装载类的时候,因为JVM的一种保护机制(具体叫啥忘了),线程是安全的。所以这种方式是属于一种线程安全,并且不会造成多余浪费的方式。但是这种方式对反射和序列化也是不安全的。
四、枚举式
public enum Singleton4 {
INSTANCE{
@Override
protected void doSomething() {
System.out.println("doSomething");
}
};
protected abstract void doSomething();
}
枚举式是Java 1.5之后才出来的一种形式,用这种形式实现单例是很简单的,并且线程安全且对反射和反序列化都是安全的。是推荐使用的一种形式。
五、懒汉式(线程不安全)
public class Singleton5 implements Serializable {
private static Singleton5 instance;
private Singleton5(){}
//提供一个静态公开的方法,当使用到该方法的时候才会去创建instance
public static Singleton5 getInstance(){
if(instance==null){
instance = new Singleton5();
}
return instance;
}
}
这种方式起到了懒加载的效果,但是只能在单线程下使用。在多线程情况下,一个线程进入了if(singleton == null)判断语句块,还未来的及往下执行,另一个线程也通过这个判断语句,这时便会产生多个实例。同时这种方式对于反射和反序列化也是不安全的
六、懒汉式(线程安全)
public class Singleton6 {
private static Singleton6 instance;
private Singleton6(){}
//提供一个静态公开的方法,当使用到该方法的时候才会去创建instance
public static synchronized Singleton6 getInstance(){
if(instance==null){
instance = new Singleton6();
}
return instance;
}
}
与懒汉式的线程不安全相比用一个synchronized
关键字实现了线程安全的问题,但同时也带了了效率低的问题。其他的问题也没有解决。
七、懒汉式(同步代码块)
public class Singleton7 {
//提供私有静态类的成员属性(不初始化)
private static Singleton7 instance = null;
//私有构造方法
private Singleton7() {
}
//对外提供公有静态方法获取对象
public static Singleton7 getInstance() {
//判断instance是否已经被初始化
if (instance == null) {
synchronized(Singleton7.class){
if(instance==null){
instance = new Singleton7();
}
}
}
return instance;
}
}
解决了线程安全但是效率不高
八、双重检查锁
public class Student5 {
//提供私有静态类的成员属性(不初始化)
private volatile static Student5 instance = null;
//私有构造方法
private Student5() {
}
//对外提供公有静态方法获取对象
public static Student5 getInstance() {
//判断instance是否已经被初始化
if (instance == null) {
synchronized(Student5.class){
if(instance==null){
instance = new Student5();
}
}
}
return instance;
}
}
这种方式是一种比较好的方式,刚开始的时候instance为null,加入两个线程a和b同时通过了第一个if判断,然后线程a先得到锁进入第二个if判断,创建了一个实例。线程b得到锁之后通过判断得到instance不为null,直接return。后续的线程再进来在第一个if那里就已经进不到if判断里面的同步代码块了。解决了线程频繁等待锁所带来的消耗。同时使用
volatile
关键字使得变量的值能够及时在主内存中刷新,保证了每个线程得到的instance的值都是最新的。