package Single;
/**
* 单例模式
* @author DMW
*/
public class Main {
/**
* 测试效率
* 饿汉式最快---------22ms
* 懒汉式相对很慢------654ms
* 相差一两个量级
* @param args
*/
/**
* 对比:
* 饿汉式效率快,不可延时加载
* 懒汉式效率慢,可延时加载
*
* 静态内部类,效率高,可延时加载
* 枚举,效率高,不可延时加载(防止反射获取)
* @param args
*/
/**
* 选择:
* 资源少,不需要延迟加载
* 枚举 优于 饿汉式
* 资源多,需要延迟加载
* 静态内部类 优于 懒汉式
* @param args
*/
public static void main(String[] args) {
SingleDemo5 instance1 = SingleDemo5.INSTANCE;
SingleDemo5 instance2 = SingleDemo5.INSTANCE;
System.out.println(instance1);
System.out.println(instance2);
}
}
package Single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.CountDownLatch;
/**
* 反射获取单例
* @author DMW
* @2019年1月15日
*/
public class Main2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
SingleDemo2 instance1 = SingleDemo2.getInstance();
SingleDemo2 instance2 = SingleDemo2.getInstance();
System.out.println(instance1);
System.out.println(instance2);
Class<SingleDemo2> clazz=(Class<SingleDemo2>) Class.forName("Single.SingleDemo2");
Constructor<SingleDemo2> constructor = clazz.getDeclaredConstructor(null);
constructor.setAccessible(true);
SingleDemo2 newInstance1 = constructor.newInstance();
SingleDemo2 newInstance2 = constructor.newInstance();
System.out.println(newInstance1);
System.out.println(newInstance2);
}
}
package Single;
import java.util.concurrent.CountDownLatch;
public class Main3 {
public static void main(String[] args) throws InterruptedException {
long start =System.currentTimeMillis();
int threadNum =10;
final CountDownLatch c= new CountDownLatch(threadNum);
for (int i = 0; i < threadNum; i++) {
new Thread( new Runnable() {
public void run() {
for (int j = 0; j < 9999999; j++) {
// SingleDemo1 instance = SingleDemo1.getInstance();
// SingleDemo2 instance = SingleDemo2.getInstance();
// SingleDemo3 instance = SingleDemo3.getInstance();
// SingleDemo4 instance = SingleDemo4.getInstance();
SingleDemo5 instance = SingleDemo5.INSTANCE;
}
c.countDown();
}
}).start();
}
c.await();
long end =System.currentTimeMillis();
System.out.println(end -start);
}
}
package Single;
/**
* 饿汉式
* @author DMW
* @2019年1月15日
*/
public class SingleDemo1 {
/**
* 1.构造器私有
* 2.static 属性
* 3.公开方法
*/
//类初始化,立即加载,非延时加载。 可能不用,存在资源浪费
private static SingleDemo1 instance =new SingleDemo1();
SingleDemo1(){
}
//方法不用同步,效率高
public static SingleDemo1 getInstance(){
return instance;
}
}
package Single;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
* 饿汉式
* @author DMW
* @2019年1月15日
*/
public class SingleDemo2 implements Serializable{
/**
* 1.私有构造器
* 2.static属性
* 3.公开方法
*/
private static SingleDemo2 instance;
private SingleDemo2(){
//防止反射获取
if(instance != null){
throw new RuntimeException();
}
}
//延迟加载,使用时创建
public static synchronized SingleDemo2 getInstance(){
if(instance == null)
instance =new SingleDemo2();
return instance;
}
//反序列化
private Object readResolve() throws ObjectStreamException{
return instance;
}
}
package Single;
/**
* 双重锁检测(据说有问题)
* @author DMW
* @2019年1月15日
*/
public class SingleDemo3 {
private static SingleDemo3 instance = null;
private SingleDemo3(){}
public static SingleDemo3 getInstance(){
if(instance ==null){
SingleDemo3 s;
synchronized (SingleDemo3.class) {
s=instance;
synchronized (SingleDemo3.class){
if(s==null){
s = new SingleDemo3();
}
}
}
}
return instance;
}
}
package Single;
/**
* 静态内部类实现
* @author DMW
* @2019年1月15日
*/
public class SingleDemo4 {
private static class SingleDemo4Instance{
private static final SingleDemo4 instance = new SingleDemo4();
}
private SingleDemo4(){}
//方法不加锁,效率高
public static SingleDemo4 getInstance(){
return SingleDemo4Instance.instance;
}
}
package Single;
/**
* 枚举实现
* @author DMW
* @2019年1月15日
*/
public enum SingleDemo5 {
// 非演示加载
INSTANCE;
public void doSomething(){
}
}