版权声明

最近很多爬虫来我博客爬文章,转载可以,但请保留原文出处及版权声明,即便是在中国

单纯的广告

个人博客:https://aodeng.cc
微信公众号:低调小熊猫
QQ群:756796932

简介

单例模式确保一个类只有一个实例,并提供一个全局访问点,上班偷偷写的文章,所以请仔细看注释

使用

懒汉式

/**
 * @program:hope
 * @author:aodeng
 * @blog:低调小熊猫(https://aodeng.cc)
 * @微信公众号:低调小熊猫
 * @create:2018-11-15 13:20
 **/
public class SingleObject {
    /**===============懒汉式(那个取的名字,本人表示根本记不住)英文名,叫 lazy loading,也就是延迟加载===============**/
    private static SingleObject instance;
    /**让构造函数为 private,这样该类就不会被实例化**/
    private SingleObject(){}
    /**但是上面代码会有一个问题,当多个线程同时调用 getInstance() 方法时,可能会产生多个instance 实例,因此这种方式并不是真正的单例。
       为了解决线程安全问题,我们只需要在getInstance() 方法上使用synchronized 关键字给线程加锁即可
       synchronized 的作用是加锁,当多个线程同时调用getInstance() 时,只有一个线程能进入,其他线程会等待进入的线程出来之后在一一进入,
       这样就能保证instance 实例是唯一的。这才是真正的单例,不过这并不是完美的解决方案,只要是锁,必然有性能损耗问题。而且对于上面的代码,
       其实我们只需要在线程第一次访问时加锁即可,之后并不需要锁,锁给我们带来了系统资源浪费**/
    public static synchronized SingleObject getInstance(){
        if (null == instance){
            instance=new SingleObject();
        }
        return instance;
    }

    private String name="低调小熊猫";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

饿汉式

/**
 * @program:hope
 * @author:aodeng
 * @blog:低调小熊猫(https://aodeng.cc)
 * @微信公众号:低调小熊猫
 * @create:2018-11-15 13:34
 **/
public class SingleObject2 {
    /**=======饿汉式(低调小熊猫表示还是记不住)新的解决方案是not lazy loading,在类加载时就创建好了实例,解决懒汉式锁给我们带来了系统资源浪费===============**/
    private static SingleObject2 instance=new SingleObject2();
    private SingleObject2(){}
    public static SingleObject2 getInstance(){
        return instance;
    }
    /**这种方式就可以保证实例唯一了**/
    private String name="低调小熊猫2";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

double-checked locking (双重检查加锁)

/**
 * @program:hope
 * @author:aodeng
 * @blog:低调小熊猫(https://aodeng.cc)
 * @微信公众号:低调小熊猫
 * @create:2018-11-15 13:45
 **/
public class SingleObject3 {
    /**=======还有一种叫 double-checked locking (双重检查加锁)==============**/
    /**这种方式主要用到两个关键字volatile 和 synchronized,synchronized 的作用是加锁,就不再多说,而volatile 关键字许多人不了解,没关系,我们先看代码**/
    private volatile static SingleObject3 instance;
    private SingleObject3(){}
    private static SingleObject3 getInstance(){
        if (null == instance) {
            synchronized (SingleObject3.class){
                if (null == instance){
                    instance =new SingleObject3();
                }
            }
        }
        return instance;
    }
    /**volatile 关键字简单来说就是可以保证instance变量在被其中一个线程new出来时,其他线程可以立即看到结果并正确的处理它。对volatile 有兴趣的朋友可以自行度娘
     * 这种方式的单例模式可以大大的减少锁所带来的性能损耗**/
    private String name="低调小熊猫3";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

TestMain

/**
 * @program:hope
 * @author:aodeng
 * @blog:低调小熊猫(https://aodeng.cc)
 * @微信公众号:低调小熊猫
 * @create:2018-11-15 13:23
 **/
public class TestMain {
    public static void main(String[] args) {
        /**======单例使用========**/
        //懒汉式
        SingleObject singleObject=SingleObject.getInstance();
        //饿汉式
        SingleObject2 singleObject2=SingleObject2.getInstance();
        //双重检查加锁,额,是不是很尴尬,我不知道怎么用这个
        //SingleObject3 singleObject3=SingleObject3.
        System.out.println(singleObject.getName());
        System.out.println(singleObject2.getName());
        /**
         * 优点
         使用单例模式,对象在内存中只有一个实例,并且无需频繁的创建和销毁对象,大大的减少了性能的损耗
         缺点:懒得打字了,可以忽略
         个人喜欢使用饿汉式单例,也就是not lazy loading,没有为什么,就是这种代码少点,嘿嘿
         **/
    }
}

源码链接

https://github.com/java-aodeng/hope