java设计模式-单例模式

单例模式
单例模式提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

何时使用？
1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

如何使用？
单例模式其实一个很简单的设计模式，我们就不过多的解释了，相信大家们一看就懂。

首先我们来介绍饿汉模式

public class SingleObject implements Single{
    private static SingleObject singleObject = new SingleObject();
    private SingleObject(){
    }
    public static SingleObject getSingleObject(){
        return singleObject;
    }
    @Override
    public void desc() {
        System.out.println("这是饿汉式，线程安全");
    }
}

然后我们在介绍懒汉模式

public class SingleObjectOne implements Single{
    private static SingleObjectOne singleObjectOne;
    private SingleObjectOne(){
    }
    public static SingleObjectOne getInstance(){
        if(singleObjectOne == null){
            singleObjectOne = new SingleObjectOne();
        }
        return singleObjectOne;
    }
    @Override
    public void desc() {
        System.out.println("这是懒汉式，线程不安全的");
    }
}

我们可以看到懒汉模式是线程不安全的，那么可不可以让她线程安全呢？我们继续看

下面是线程安全的懒汉模式

public class SingleObjectTwo implements Single{
    private static SingleObjectTwo singleObjectTwo;
    private SingleObjectTwo(){
    }
    public  synchronized static SingleObjectTwo getInstance(){
        if(singleObjectTwo == null){
            singleObjectTwo = new SingleObjectTwo();
        }
        return singleObjectTwo;
    }
    @Override
    public void desc() {
        System.out.println("这是懒汉式线程安全的");
    }
}

最后是一种高性能并且线程安全的懒汉模式

public class SingleObjectThree implements Single {
    private static SingleObjectThree singleObjectThree;
    private SingleObjectThree(){
    }
    public static SingleObjectThree getInstance(){
        if(singleObjectThree == null){
            synchronized (SingleObjectThree.class){
                if(singleObjectThree == null){
                    singleObjectThree = new SingleObjectThree();
                }
            }
        }
        return singleObjectThree;
    }
    @Override
    public void desc() {
        System.out.println("这是懒汉双重检锁，性能高，线程安全");
    }
}

下面我们来测试一下这四种单例模式吧

public class Demo {
    public static void main(String[] args) {
        SingleObject singleObject = SingleObject.getSingleObject();
        singleObject.desc();
        SingleObjectOne singleObjectOne = SingleObjectOne.getInstance();
        singleObjectOne.desc();
        SingleObjectTwo singleObjectTwo = SingleObjectTwo.getInstance();
        singleObjectTwo.desc();
        SingleObjectThree singleObjectThree = SingleObjectThree.getInstance();
        singleObjectThree.desc();
    }
}

总结
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

2、避免对资源的多重占用。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。