使用Java实现单例模式

现在小叮当成为了波音的首席CEO，他买了一辆奔驰汽车，他决定和他的好兄弟小叮咚一起开这辆车。但是他们只有一辆车，这样我们不能像奔驰工厂那样，创建很多奔驰汽车，我们只能创建一辆奔驰汽车。

1-写一个BenzCar类

public class BenzCar {
    //车的拥有者
    private String owner;
    //车的名字
    private String name;

    public BenzCar(String name, String owner) {
        this.name = name;
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    public String getName() {
        return name;
    }
}

public class Demo {
    public static void main(String[] args) {
        BenzCar benzCar = new BenzCar("奔驰","小叮当");
        System.out.println("小叮当在开:"+benzCar.hashCode());

        BenzCar benzCar1 = new BenzCar("奔驰", "小叮当");
        System.out.println("小叮咚在开:"+benzCar1.hashCode());
    }
}

 

很明显,虽然benzCar和benzCar1的属性都是"奔驰"和"小叮当",但是他们的hashcode却不相等,这意味着,在计算机(jvm)看来,实际上他们创建了两个对象.占用了两份内存.实际小叮当只有一辆车,计算机模型和真实世界的模型不一致了.会导致程序出现问题.如何解决这个问题呢?

2-我们可以使用单例模式解决这个问题,让BenzCar只能创建一个对象.开始改造BenzCar类.

第一步: 将构造函数改为私有,不允许客户端调用

    //将构造函数改为私有方法
    private BenzCar(String name, String owner) {
        this.name = name;
        this.owner = owner;
    }

第二步: 新增一个私有静态成员变量保存奔驰汽车实例

    //私有静态成员变量
    private static BenzCar benzCar;

第三步: 新增一个公开的方法获取奔驰汽车实例

    //客户端获取奔驰汽车方法
    public static BenzCar getBenzCar(){
        //如果不存在这个实例，就创建一个
        if ( null == benzCar){
            benzCar = new BenzCar("奔驰","小叮当");
            return benzCar;
        }
        //有的话就直接返回
        return benzCar;
    }

完整代码

public class BenzCar {
    //车的拥有者
    private String owner;
    //车的名字
    private String name;

    //私有静态成员变量
    private static BenzCar benzCar;
    //客户端获取奔驰汽车方法
    public static BenzCar getBenzCar(){
        //如果不存在这个实例，就创建一个
        if ( null == benzCar){
            benzCar = new BenzCar("奔驰","小叮当");
            return benzCar;
        }
        //有的话就直接返回
        return benzCar;
    }
    //将构造函数改为私有方法
    private BenzCar(String name, String owner) {
        this.name = name;
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    public String getName() {
        return name;
    }
}

3-这样在客户端不管调用多少次都是同一个实例对象（多线程模式下例外）.如下:

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            BenzCar benzCar = BenzCar.getBenzCar();
            System.out.println(benzCar.getOwner()+ "的" + benzCar.getName() + benzCar.hashCode());
        }
    }
}

4-使用多线程创建单例模式；如果你是一个高手程序员，你一定知道怎么去使用多线程写程序，那么在使用多线程创建对象的过程中，依然有可能导致创建BenzCar对象。例如：

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                BenzCar benzCar = BenzCar.getBenzCar();
                System.out.println(benzCar.getOwner()+ "的" + benzCar.getName() + benzCar.hashCode());
            }).start();
        }
    }
}

 要如何解决这个问题呢，有两种解决方案，饿汉式和懒汉式。我们先来介绍饿汉式：

5-单例模式（饿汉式）

新建一个BoeingPlane类，属性和BenzCar相同,将BoeingPlane对象在程序启动的时候就实例化一个不可变的对象，后续所有人都用这个唯一的对象。

public class BoeingPlane {

    private String name;
    private String owner;
    //static表示只能有boeingPlane一个实例，final标识它不能修改
    private static final BoeingPlane boeingPlane = new BoeingPlane("飞机","小叮当");

    /**
     * 获取实例时直接返回
     * @return
     */
    public static BoeingPlane getBoeingPlane(){
        return boeingPlane;
    }

    private BoeingPlane(String name, String owner){
        this.name = name;
        this.owner = owner;
    }

    public String getName() {
        return name;
    }

    public String getOwner() {
        return owner;
    }
}

测试一下

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                BenzCar benzCar = BenzCar.getBenzCar();
                System.out.println(benzCar.getOwner()+ "的" + benzCar.getName() + benzCar.hashCode());
            }).start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                BoeingPlane boeingPlane = BoeingPlane.getBoeingPlane();
                System.out.println(boeingPlane.getOwner()+"的"+boeingPlane.getName()+boeingPlane.hashCode());
            }).start();
        }
    }
}

可以看到飞机的hashcode都是一样的，代表都是同一个对象的实例。

6-单例模式（懒汉式） 

饿汉式在程序启动的时候就加载完毕了，如果实例占用的资源比较多，在没用到的时候就实例化肯定是一种资源浪费。还有没有其他的解决思路呢，既然是在多线程下才会有这个问题，那我们加锁就好了，创建实例的时候给对象加锁，同一时间只让一个线程访问就好了。

改造一下BenCar类，给它加锁。

public class BenzCar {
    //车的拥有者
    private String owner;
    //车的名字
    private String name;

    //私有静态成员变量
    private volatile static BenzCar benzCar;
    //客户端获取奔驰汽车方法
    public static BenzCar getBenzCar(){
        //如果不存在这个实例，就创建一个
        if ( null == benzCar){
            //给对象加锁，同一时间只有一个线程能访问下面的方法
            synchronized (BenzCar.class){
                //双重判断，一开始的时候一个对象也没有，锁会不生效
                if ( null == benzCar){
                    benzCar = new BenzCar("奔驰","小叮当");
                }
            }

            return benzCar;
        }
        //有的话就直接返回
        return benzCar;
    }
    //将构造函数改为私有方法
    private BenzCar(String name, String owner) {
        this.name = name;
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    public String getName() {
        return name;
    }
}

测试一下（测试代码同上）

总结一下， 饿汉式第一次就加载完成，会一直占用资源，懒汉式在用到的时候才加载，由于设计到锁机制，第一次初始化实例的时间比较长。很奇怪为什么叫饿汉式和懒汉式QAQ