Java 设计模式 – 单例模式 Singleton Pattern

在一些程序设计中，希望对象只有一个实例，这时候就可以使用单例模式。单例模式的实现，在语法上 用一个私有的构造方法来保护类不能在外部被 new 出来，然后提供一个静态方法返回唯一的实例即可。

应用场景，例如：系统配置，整个系统有一个配置对象即可，如果有配置修改，通知这个唯一的对象就好了，每次读取配置只需从这个唯一的对象中获取。

下面是一些常见的写法，以及优缺点：

实现方式一

package cn.devdoc.dp.creational.singleton;

/**
 * <p>
 * 最简单的单例模式，在多线程的情况下依然能保持单例。
 * </p>
 * 
 * @author CK
 *
 */
public class Singleton1 {

    private final static Singleton1 instance = new Singleton1();

    static {
        // 在这里初始化 instance 其实都一样，都是在类初始化即实例化instance。
    }

    private Singleton1() {

    }

    public static Singleton1 getInstance() {
        return instance;
    }

}

这是最简单的单例模式，在多线程的情况下依然能保持单例。这种方式基于classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，没有达到 lazy loading 的效果。

实现方式二

package cn.devdoc.dp.creational.singleton;

/**
 * 
 * @author CK
 *
 */
public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2() {

    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // 在多线程的时候这里会出问题，导致的后果就是创建了多个实例

            // 为测试效果，假设这里需要5秒才能完成创建实例
            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton2();
        }
        return instance;
    }
}

在调用 getInstance 方法时才实例化对象，但多线程环境下会创建出多个对象。

实现方式三

package cn.devdoc.dp.creational.singleton;

/**
 * <p>
 * 这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。
 * </p>
 * 
 * @author CK
 *
 */
public class Singleton3 {

    private static Singleton3 instance = null;

    private Singleton3() {
    }

    public static synchronized Singleton3 getInstance() {
        if (instance == null) {

            // 为测试效果，假设这里需要5秒才能完成创建实例
            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            instance = new Singleton3();
        }
        return instance;
    }
}

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的 lazy loading，但是，遗憾的是，效率很低，除了第一次，其它情况都不需要同步。

实现方式四

package cn.devdoc.dp.creational.singleton;

/**
 * <p>
 * 双检锁，解决同步锁的性能问题，只有还没实例化的时候才会锁
 * </p>
 * 
 * @author CK
 *
 */
public class Singleton4 {

    private volatile static Singleton4 instance;

    private Singleton4() {
    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            // 只有instance还没被实例化的时候才会到这里，但有可能多个线程都执行到这了。
            synchronized (Singleton4.class) {
                // 进入到if中的线程有多个，前面的线程可能已经实例化了instance，所以需要再次判断。
                if (instance == null) {
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }

}

双检锁，解决同步锁的性能问题，只有还没实例化的时候才会锁

实现方式五

package cn.devdoc.dp.creational.singleton;

/**
 * <p>
 * 基于静态内部类实现的单例模式
 * </p>
 * 
 * @author CK
 *
 */
public class Singleton5 {

    private static class SingletonHolder {
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5() {
    }

    public static Singleton5 getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

通过内部类实现的，其它还有通过枚举实现的。

测试

package cn.devdoc.dp.creational.singleton;

import org.junit.Assert;
import org.junit.Test;

public class SingletonTest {

    @Test
    public void test0() {
        SingletonTest dp1 = new SingletonTest();
        SingletonTest dp2 = new SingletonTest();

        Assert.assertFalse(dp1.equals(dp2));
        Assert.assertFalse(dp1.hashCode() == dp2.hashCode());
    }

    @Test
    public void test1() {
        Singleton1 ins1 = Singleton1.getInstance();
        Singleton1 ins2 = Singleton1.getInstance();

        Assert.assertTrue(ins1.equals(ins2));
        Assert.assertTrue(ins1.hashCode() == ins2.hashCode());

        System.out.println(ins1);
        System.out.println(ins1.hashCode());

        // 模拟多线程的场景
        Runnable r = new Runnable() {
            @Override
            public void run() {
                Singleton1 single = Singleton1.getInstance();
                System.out.println(single.hashCode());
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }

    @Test
    public void test2() {

        // 模拟多线程的场景，多运行几次会发现有不一样的hashCode
        Runnable r = new Runnable() {
            @Override
            public void run() {
                Singleton2 single = Singleton2.getInstance();
                System.out.println(single.hashCode());
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }

    @Test
    public void test3() {

        // 模拟多线程的场景，无论怎么运行hashCode都是一样的
        Runnable r = new Runnable() {
            @Override
            public void run() {
                Singleton3 single = Singleton3.getInstance();
                System.out.println(single.hashCode());
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }

    @Test
    public void test4() {

        // 模拟多线程的场景，无论怎么运行hashCode都是一样的

        Runnable r = new Runnable() {
            @Override
            public void run() {
                Singleton4 single = Singleton4.getInstance();
                System.out.println(single.hashCode());
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }

    @Test
    public void test5() {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                Singleton5 single = Singleton5.getInstance();
                System.out.println(single.hashCode());
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }
}

测试结果

• test0：测试出普通类 new 出来的2个对象 地址和 hashCode 都不一样
• test1：模拟线程测试，hashCode 是一样的
• test2：模拟线程测试，会有 hashCode 不一样的情况，这是多线程造成的。
• test3：模拟线程测试，无论怎么测试，hashCode 都一样
• test4：模拟线程测试，无论怎么测试，hashCode 都一样
• test5：模拟线程测试，无论怎么测试，hashCode 都一样