Java高并发系列3 -再写单例

Java高并发系列3 -再写单例

接高并发系列上一篇Java高并发系列2-并发锁
这篇我们来说说高并发下的单例。

单例模式是最常用到的设计模式之一，熟悉设计模式的朋友对单例模式都不会陌生。非线程安全的单例设计这里不再提及，主要涉及线程安全的单例设计。

1.

看一条设计

public class Singleton {
    private static Singleton sin=new Singleton();    ///直接初始化一个实例对象
    private Singleton(){    ///private类型的构造函数，保证其他类对象不能直接new一个该对象的实例
    }
    public static Singleton getSin(){    ///该类唯一的一个public方法    
        return sin;
    }
}

上述代码中的一个缺点是该类加载的时候就会直接new 一个静态对象出来，但是如果从始至终都没有使用，便会浪费系统资源。 当系统中这样的类较多时，会使得启动速度变慢 。

现在流行的设计都是讲“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象。所以这种适合在小系统。

2.

看一条设计

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这个通过synchronized 加锁实现了线程同步 。不推荐使用

缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。 这个粒度有点大进行同步效率太低要改进。

3.

再来看一条

public class Singleton4 {
    // 私有构造
    private Singleton4() {}

    private volatile static Singleton4 single = null;

    // 双重检查
    public static Singleton4 getInstance() {
        if (single == null) {
            synchronized (Singleton4.class) {
                if (single == null) {
                    single = new Singleton4();
                }
            }
        }
        return single;
    }
}

Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

优点：线程安全；延迟加载；效率较高。推荐用

4.

再来看一条

静态内部类实现

public class Singleton {
	
	private Singleton() {
		System.out.println("single");
	}
	
	private static class Inner {
		private static Singleton s = new Singleton();
	}
	
	public static Singleton getSingle() {
	     Inner 的s  只有再调用这句话的时候才会实现静态内部类的s对象。 
		return Inner.s;
	}

5.

再来看一条

public class SingletonFactory {
	
	// 内部枚举类
	private enum EnmuSingleton{
		Singleton;
		private Singleton8 singleton;
		
		//枚举类的构造方法在类加载是被实例化 
		private EnmuSingleton(){
			singleton = new Singleton8();
		}
		public Singleton8 getInstance(){
			return singleton;
		}
	}
	public static Singleton8 getInstance() {
		return EnmuSingleton.Singleton.getInstance();
	}
}

class Singleton8{
	public Singleton8(){}
}

这是一种枚举实现。 在当SingletonFactory 调用getInstance 方法之前， Singleton8 这个对象是不会实例化的。 也就是当EnmuSingleton. 的时候才会实例化 ，然后通过枚举推类型 Singleton ，调用枚举方法 getInstance() 来获取单例对象。 实现上较复杂， 实际开发中少见。

好了， 啰里啰嗦，说了一大通，单例的种类还是比较多的， 至于用哪一种，还是根据自己的需要，适合自己项目的才是最好的。 东西比较多，如果有什么不对的，请批评指正。 这篇就先说到这里，下篇我们再见。