单例模式-七种写法

设计模式-总览https://mp.csdn.net/mp_blog/creation/editor/122202507单例模式使用特点：

        1、保证系统从启动到停止，只能产生一个实例。

        2、应用中遇到冲突的时候，即产生了两个实例会有问题的时候。

以下是单例模式的实现方式：

package demo.lihongmin.singleton;

// 饿汉式 单例模式
public class Singleton1 {

	// 构造私有
	private Singleton1(){}
	// 声明一个静态变量保存单利的引用
	private static final Singleton1 single = new Singleton1();
	// 通过静态方法获取单利的引用
	public static Singleton1 getInstance(){
		return single;
	}
}单例模式
public class Singleton1 {

	// 构造私有
	private Singleton1(){}
	// 声明一个静态变量保存单利的引用
	private static final Singleton1 single = new Singleton1();
	// 通过静态方法获取单利的引用
	public static Singleton1 getInstance(){
		return single;
	}
}

package demo.netty_lihongmin.singleton;

// 懒汉式单例模式，保证线程安全
public class Singleton2 {

	// 构造私有
	private Singleton2(){}
	// 声明一个静态变量保存单利的引用
	private static Singleton2 single = null;
	// 通过静态方法获取单利的引用，并保证线程的安全
	public static synchronized Singleton2 getInstance(){
		if(single == null) {
			single = new Singleton2();
		}
		return single;
	}
}

package demo.netty_lihongmin.singleton;

// 懒汉式单例模式，保证线程安全
public class Singleton3 {

	// 构造私有
	private Singleton3(){}
	// 声明一个静态变量保存单利的引用
	private static Singleton3 single = null;
	// 通过静态方法获取单利的引用，并保证线程的安全使用双重锁检查
	public static Singleton3 getInstance(){
		if(single == null) {
			synchronized(Singleton3.class){
				if(single == null) {
					single = new Singleton3();
				}
			}
		}
		return single;
	}
}

package demo.netty_lihongmin.singleton;

/**
 *  内部类的单例模式
 *  注意点： 内部类的初始化需要依赖主类
 */
public class Singleton4 {

	// 构造私有
	private Singleton4(){}
	// 声明一个静态内部类
	private static class InnerClass {
		// final 是防止内部类将这个属性进行覆盖
		private static final Singleton4 INSTANCE = new Singleton4();
	}
	// final 是防止子类从写父类的方法
	public static final Singleton4 getInstance(){
		return InnerClass.INSTANCE;
	}
}

package demo.netty_lihongmin.singleton;


public class Singleton5 {

	String name = null;
	// 构造私有
	private Singleton5(){}
	// 使用volatile关键字
	private static volatile Singleton5 instance = null; 
		
	// final 是防止子类从写父类的方法
	public static Singleton5 getInstance(){
		if(instance == null) {
			synchronized(Singleton5.class) {
				if(instance == null) {
					instance = new Singleton5();
				}
			}
		}
		return instance;
	}
}

package demo.netty_lihongmin.singleton;


public enum Singleton6 {
	INSTANCE;
	// 构造私有
	private Singleton6(){}
}

package demo.netty_lihongmin.singleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// spring方式
public class Singleton7 {

	private static Map<String,Singleton7> map = new ConcurrentHashMap<String,Singleton7>();
	static{
		Singleton7 single = new Singleton7();
		map.put(single.getClass().getName(), single);
	}
	
	// 构造私有
	private Singleton7(){}
		
	public static Singleton7 getInstance(String name){
		if(name ==null) {
			name = Singleton7.class.getName();
		}
		if(map.get(name) == null) {
			try{
					map.put(name, (Singleton7)Class.forName(name).newInstance());
			} catch (InstantiationException e){
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		return map.get(name);
	}
}

package demo.netty_lihongmin.singleton;

import java.util.concurrent.CountDownLatch;

public class SingletonTest {

	public static void main(String[] args) {
		int count = 100;
		
		CountDownLatch latch = new CountDownLatch(count);
		
		for(int i=0 ; i<count ; i++) {
			new Thread(){
				public void run() {
					System.out.println(System.currentTimeMillis()+" "+ Singleton4.getInstance());
				};
			}.start();
		}
		
		try {
			latch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}