单例模式

定义：共享资源，只需要初始化一次，就能大家一起使用，重复使用。实现方案，构造方法私有，开放统一出口

 

恶汉模式：它是在类加载的时候就立即初始化，并且创建单例对象，绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题

缺点是站茅坑不拉屎，不管你用不用我都在

public class Hungry {



private Hungry(){}



private static final Hungry hungry = new Hungry();



public static Hungry getInstance(){

return hungry;

}



}

 

懒汉模式：用户调用是初始化，线程不安全：当有线程同时访问未初始化的单例时，创建的对象会不一致。

/**

* created by ldl 2018/7/20

*/

//单例最简单写法

public class SingletonOne {

private SingletonOne(){}//单例构造私有



private static SingletonOne singletonOne=null;



public SingletonOne getSingletonOne(){

if(singletonOne==null){//当存在并发线程时会存在同时进入if，so线程非安全

singletonOne=new SingletonOne();

}

//如果存在则直接返回

return singletonOne;

}

}



来一发并发创建实例验证线程安全：

/**

* created by ldl 2018/7/20

*/

public class Test {

public static void main(String[] args) {

int num = 300;

CountDownLatch countDownLatch=new CountDownLatch(num);

for (int i = 0; i < num; i++) {//有一定的几率，多执行几次

new Thread() {

@Override

public void run() {

try {

try{

countDownLatch.await();//当num=0的时候统一释放

}catch (Exception e){

e.printStackTrace();

}

Object obj = SingletonOne.getSingletonOne();//创建单例对象

System.out.println(obj);//输出看每次调用的对象是否一致，如果不一致则线程不安全

}catch (Exception e){

e.printStackTrace();

}

}

}.start();

countDownLatch.countDown();

}

}

}

执行结果

com.ldl.microservice.singleton.SingletonOne@2e24d89c//发现不一样了

com.ldl.microservice.singleton.SingletonOne@56a590e

com.ldl.microservice.singleton.SingletonOne@56a590e

com.ldl.microservice.singleton.SingletonOne@56a590e

com.ldl.microservice.singleton.SingletonOne@56a590e

com.ldl.microservice.singleton.SingletonOne@56a590e

 

如果在懒汉模式下保证线程安全？

关键字：synchronized

代码实现：

public class SingletonTwo {

private SingletonTwo(){



}

private static SingletonTwo singletonTwo=null;

public static synchronized SingletonTwo getSingletonTwo(){

if(singletonTwo==null){

singletonTwo=new SingletonTwo();

}

return singletonTwo;

}

}

//这样做有什么隐患呢？ 下面来一发比较

/**
 * created by ldl 2018/7/20
 * 同样的代码线程同步比较运行时间
 */
public class TestConsume {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 300000000; i++) {
            SingletonOne.getSingletonOne();
        }
        long end = System.currentTimeMillis();
        System.out.println("消耗时间" + (end - start));
    }
}
消耗时间5

Process finished with exit code 0



/**
 * created by ldl 2018/7/20
 * 同样的代码线程同步比较运行时间
 */
public class TestConsume {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 300000000; i++) {
            SingletonTwo.getSingletonTwo();
        }
        long end = System.currentTimeMillis();
        System.out.println("消耗时间" + (end - start));
    }
}

消耗时间7382

Process finished with exit code 0

 

这个相差没的说了。事实证明懒汉模式下这种方式解决线程安全是不可取的

怎么做呢？

内部类，当外部类访问单例类的时候优先加载内部类，将单例类在内部类里面创建 ，内部类static，private，final 关键字一上，巧妙避免线程安全问题（反射除外）

/**

* created by ldl 2018/7/20

*/

public class SingletonThree {

private SingletonThree(){



}

//final 防止方法被修改

public static final SingletonThree getSingletonThree(){

return LoadClass.SINGLETON_THREE;

}

private static class LoadClass{

private static final SingletonThree SINGLETON_THREE=new SingletonThree();

}

}

对应反射之后强制访问修改属性的操作，这里不做介绍