用Java设计单例模式

设计模式——单例

今天老师给我们出题，请设计一个单例。然而我连什么叫单例都不知道，老师叫我们先百度，好家伙，百度完了我直接抄了原码。老师说面试的时候至少要会写一种，好叭，来做个笔记呗。

（一）概念：

单例：保证一个类，只有一个实例，并且提供一个访问该实例的全局访问地。

注意：

• 1、单例类只能有一个实例。

• 2、单例类必须自己创建自己的唯一实例。

• 3、单例类必须给所有其他对象提供这一实例。

（二）优缺点：

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

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

（三）使用场景

• 1、要求生产唯一序列号。
• 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

**注意事项：**getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

（四）实现原理图

（五）代码实现

1.饿汉式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。

步骤一，创建一个Cat类

package entity;

public class Cat {
    //1.准备一个静态的唯一实例。静态方法是先产生的。
    private static Cat instance = new Cat();
    //2.让构造函数为private，这样该类就不会被实例化
    private Cat(){}
    //3.静态获取唯一可用的对象
    public static Cat getInstance(){
        return instance;
    }

}

步骤二，从Cat类中获取唯一的对象

package test;

import entity.Cat;

public class Demo1 {
    public static void main(String[] args) {
        Cat cat1 = Cat.getInstance();
        Cat cat2 = Cat.getInstance();
        System.out.println(cat1);
        System.out.println(cat2);
        //比较地址，相同说明只有一个实例，返回true
        System.out.println(cat1 == cat2);
        //类要使用，要先进内存，并形成一个字节码对象
        //顺便可以打印字节码对象
        System.out.println(Cat.class);
    }
}

步骤三，程序执行，输出结果：

entity.Cat@1b6d3586
entity.Cat@1b6d3586
true
class entity.Cat

优点：第一次调用才初始化，避免内存浪费。
缺点：类加载时就实例化了，没有达到Lazy Loading (懒加载) 的效果如果该实例没被使用，内存就浪费了。

2.懒汉式：在类加载时不初始化，等到第一次被使用时才初始化。

步骤一，创建一个Dog类

package entity;

public class Dog {
    //1.准备一个静态的唯一空实例
    private static Dog instance;//懒汉
    //2.构造函数私有化，这样该类就不会被实例化
    private Dog(){
        System.out.println("Dog() is called...");
    }
    //3.静态获取唯一可用的对象
    // 3.1synchronized写在静态方法上，同步规则，静态字节码对象（唯一）
    public static synchronized Dog getInstance(){
        if (instance == null){
            try {
                Thread.sleep(10);//让线程睡10毫秒，并抓起异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Dog();
        }
      return instance;
    }

}

   //3.2.synchronized写在静态方法内，同步规则，静态字节码对象（唯一）
    public static Dog getInstance(){
        if(instance == null) {
            synchronized (Dog.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(10);//让线程睡10毫秒，并抓起异常
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Dog();
                }
            }
        }
        return instance;
    }

步骤二：

package test;

import entity.Dog;

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Dog dog1 = Dog.getInstance();
        Dog dog2 = Dog.getInstance();
        System.out.println(dog1);
        System.out.println(dog2);
        //比较地址，相同说明只有一个实例，返回true
        System.out.println(dog1 == dog2);
        //字节码对象
        System.out.println(Dog.class == Class.forName("entity.Dog"));


        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Dog.getInstance());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Dog.getInstance());
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Dog.getInstance());
            }
        });

    }
}

优缺点：
资源利用效率高，但是每次调用getInstance() 方法都要同步，效率较低

3.内部类

步骤一：

package entity;

public class Pig {
    //1、构造函数私有化
    private Pig(){
        System.out.println("Pig() is called...");
    }
    //2、静态的获取实例方法
    public static Pig getInstance(){
        return Xxx.instance;
    }
    //3、内部类
    public static class Xxx{
        private static Pig instance = new Pig();
    }
}

步骤二：

package test;

import entity.Pig;

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println(Pig.class == Class.forName("entity.Pig"));
        Pig pig1 = Pig.getInstance();
        Pig pig2 = Pig.getInstance();
        System.out.println(pig1);
        System.out.println(pig2);
        System.out.println(pig1==pig2);
    }
}

暂时先到这，后续也许会补充。