Java设计模式-单例模式及线程安全问题

单例模式是非常常用的设计模式,他确保了一个类只有一个对象,并且这个对象是自己创建的,外界可以获取使用到这个对象。


单例模式一般有两种:懒汉式,饿汉式(其实还有一种登记式,把创建的对象放在map集合中,有就直接用,没有就创建)

单例模式通过构造方法私有化,外界无法创建对象,下面是两种单例的实现

饿汉式:

package demo_singleton;

public class SingletonHungry {
    private static SingletonHungry singletonhunary = new SingletonHungry();

    public static SingletonHungry getinstance() {
        return singletonhunary;
    }

    private SingletonHungry() {

    }


}

懒汉式:

package demo_singleton;
/*懒汉式的单例模式,有线程安全问题,当多线程访问的时候,会出现多个实例*/
public class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

    private SingletonLazy() {

    }
}

多线程环境下的测试:

懒汉式测试:

package demo_singleton;

public class TestLary extends Thread{
    public static void main(String[] args) {
        TestLary t1 = new TestLary();
        TestLary t2 = new TestLary();
        TestLary t3 = new TestLary();
        t1.start();
        t2.start();
        t3.start();
    }

    public void run() {
        System.out.println(SingletonLazy.getInstance());
    }
}

输出结果:

demo_singleton.SingletonLazy@529e3fc2
demo_singleton.SingletonLazy@529e3fc2
demo_singleton.SingletonLazy@136c03ee

通过输出结果可以看到,其实创建了两个对象

饿汉式测试:

package demo_singleton;

public class TestHungry extends Thread {
    public static void main(String[] args) {
        TestHungry t1 = new TestHungry();
        TestHungry t2 = new TestHungry();
        TestHungry t3 = new TestHungry();
        t1.start();
        t2.start();
        t3.start();
    }

    @Override
    public void run() {
        System.out.println(SingletonHungry.getinstance());
    }

}

输出结果:

demo_singleton.SingletonHungry@6d15a113
demo_singleton.SingletonHungry@6d15a113
demo_singleton.SingletonHungry@6d15a113
在多线程下饿汉式没有出现问题

在单线程的环境下,单例可以实现,当在多线程的条件下,懒汉式的单例就会出现线程安全问题,而饿汉式不会出现。饿汉式代码简单所以线程安全,在类加载的时候创建对象,懒汉式不会再在载的时候创建对象,效率高。代码中有判断对象是否存在的代码,所以线程不安全饿汉式不需要关注多线程问题,写法简单,但是有个缺点,就是不管你用或者不用,在类加载的时候他都会创建对象,而懒汉式的特点是延时加载,但是又带来了线程问题。既然这样我们就要解决它

开始解决懒汉式的问题,最开始想到的是同步,加上synchronized关键字:

优化一:

package demo_singleton;

public class SingletonLazy1 {
    private static SingletonLazy1 instance1 = null;

    public static synchronized SingletonLazy1 getInstance() {
        if (instance1 == null) {
            instance1 = new SingletonLazy1();
        }
        return instance1;
    }

    private SingletonLazy1() {

    }
}

优化二:


加入同步块,对代码进行操作

package demo_singleton;
/*加同步块的单例,效率有问题*/

public class SingletonLazy2 {
    private static SingletonLazy2 instance2 = null;

    public static SingletonLazy2 getInstance() {
        synchronized (SingletonLazy2.class) {
            if (instance2 == null) {
                instance2 = new SingletonLazy2();
            }
        }
        return instance2;
    }

    private SingletonLazy2() {

    }
}

优化三:

package demo_singleton;

public class SingletonLazy3 {
    private static SingletonLazy3 instace3 = null;

    public static SingletonLazy3 getInstance() {
        if (instace3 == null) {
            synchronized (SingletonLazy3.class) {
                if (instace3 == null) {
                    instace3 = new SingletonLazy3();
                }
            }
        }
        return instace3;
    }

    private SingletonLazy3() {

    }
}

相对于前两个优化,利用同步解决线程问题,第三个利用两个判断,当程序判断对象没有创建的时候进入执行同步代码块,创建对象。在下次判断对象存在的时候,不会再执行同步代码块中的代码,相对于前两个效率会搞一些

优化四:

package demo_singleton;

public class SingletonLazy4 {
    private static SingletonLazy4 instance4 = null;
    static{
        instance4 = new SingletonLazy4();
    }

    public static SingletonLazy4 getInstance() {

        return instance4;
    }

    private SingletonLazy4() {

    }
}

利用static静态代码块的特点,创建对象,static代码块在类加载的时候最开始执行并且只会执行一次

优化五:

package demo_singleton;

public class SingletonLazy5 {
    private static class Sing {
        private static SingletonLazy5 instance = new SingletonLazy5();
    }

    public static SingletonLazy5 getInstance() {
        return Sing.instance;
    }

    private SingletonLazy5() {

    }
}

利用静态内部类,内部类在编译的时候也是一个单独的class文件,在调用的时候会执行,不调用的时候不会执行

注意:利用Java的反射机制也是可以破坏单例的


参考:http://blog.csdn.net/cselmu9/article/details/51366946

posted @ 2017-11-10 21:29  In_new  阅读(282)  评论(0编辑  收藏  举报