单例模式代码-面试

恶汉模式：类.属性得到对象

1.

public class Singleton1 {
//为了实现类名.属性，使用static修饰符，final强调唯一
	public static final Singleton1 INTANCE = new Singleton1();
	//既然唯一就不能被调用构造方法创建对象，故私有
	private Singleton1() {
		
	}
}

2.枚举

public enum Singleton2 {
	INSTANCE
}

3.静态代码块：

public class Singleton3 {
	private static final Singleton3 INTANCE ;
	static {
		INTANCE = new Singleton3();
	}
	private Singleton3() {
		
	}
}

懒汉模式：类.方法创建对象

1.单线程

public class Singleton4 {
//不能直接被使用类名.属性调用，避免null，故私有
		private static Singleton4 instance;
		private Singleton4() {
			
		}
		public static Singleton4 getInstance() {
		//空才创建，实现唯一
			if(instance == null) {
				try {
					Thread.sleep(100);
				}catch(Exception e) {
					e.printStackTrace();
				}
				instance = new Singleton4();
			}
			return instance;
		}
}

2.多线程

public class Singleton5 {
	public static Singleton5 instance;
	private Singleton5() {
		
	}
	public static Singleton5 getInstance() {
	//多线程下，线程1执行到if(instance == null) 休眠，instance == null，此时线程2抢占cpu，执行到if(instance == null)，instance 还是为null，此时无论哪个执行下去，都会创建两个对象，加锁，一个全部执行完才能让另一个执行
		synchronized(Singleton5.class) {
			if(instance == null) {
				try {
					Thread.sleep(100);
				}catch(Exception e) {
					e.printStackTrace();
				}
				instance = new Singleton5();
			}
		}
		return instance;
	}
}

3.多线程提高效率

public class Singleton6 {
	public static Singleton6 instance;
	private Singleton6() {
		
	}
	public static Singleton6 getInstance() {
	//先判断，提高效率
		if(instance == null) {
			synchronized(Singleton5.class) {
				if(instance == null) {
					try {
						Thread.sleep(100);
					}catch(Exception e) {
						e.printStackTrace();
					}
					instance = new Singleton6();
				}
			}	
		}
		return instance;
	}
}

4.多线程（内部类实现）

public class Singleton7 {
	private Singleton7() {
		
	}
	//内部类加载才会创建对象
	private static class inner{
		private static final Singleton7 INSTANCE = new Singleton7();
	}
	public static Singleton7 getInstance() {
		return inner.INSTANCE;
	}
}