Java单例模式

    在Java的实际开发中，我们也许会有这样的需求：再创建一个类的时候只需要一个对象，不需要再创建更多的对象，但是普通的类中是可以创建任意多个对象的。那么为了解决这种问题，我们应该来使用单例模式。

    首先，我介绍一下单例模式的特点

        1：单例模式默认只能拥有一个实例。

        2：单例模式的实例必须由自己在类中创建。

        3：单例类必须向其他的对象提供自己的实例。

    单例模式的实现，我在这里介绍三种方法，分别是懒汉设计模式，饿汉设计模式，静态内部类设计模式。

    懒汉设计模式：

class Singletion{//懒汉设计模式（需要的时候才创建实例化对象）
    private static Singletion New_Singletion;//先不实例化对象
    private Singletion(){}//必须把构造方法设置成私有的，防止在类外创建新对象
    public static Singletion Get_New_Singletion(){//向别的对象提供获得实例的方法
        if(singletion == null){//如果对象还没有实例化的话就实例化
            singletion = new Singletion();
        }
        return singletion;
    }
}

    懒汉设计模式的核心思想是，先创建对象而不实例化，等到外部第一次调用Get_New_Singletion()方法的时候实例化对象，又因为单例类的对象是在类加载的时候创建的static属性，所以它只调用一次，只在堆上创建一片空间。所以，即使你在外部创建多少个单例类的对象，所指向的空间都是一块空间而已。

    但是这种设计模式又存在一些缺点：他没有考虑到线程的安全性，可能会被多个线程同时访问而创建了了很多对象。为了解决这个问题，我们可以在Get_New_Singletion()方法之前加锁(sychronized)；这里加锁的意思是：不管那一个线程运行到被synchronized修饰的方法时，都会检查有没有其他的线程正在使用这个方法，如果有线程正在使用此方法，那么此线程就会等待其运行完此方法后再运行此方法。如果此方法没有其他的线程在调用，则直接运行此方法。

    加锁之后的懒汉设计模式（只做了一些小小的改动）

class Singletion{//懒汉设计模式（需要的时候才创建实例化对象）
    private static Singletion singletion;
    private Singletion(){}
    public static synchronized Singletion Get_New_Singletion(){//加锁
        if(singletion == null){
            singletion = new Singletion();
        }
        return singletion;
    }
}

    这样就保证了线程的安全性，但是，这种方式相当于只针对了并发一种情况，在其他的时候这个锁下相当于没有起作用，所以这种改动会让程序的效率降低。

    接下来我介绍下一种模式：饿汉设计模式。先上代码

class Singletion{//饿汉设计模式（不管有没有需要，加载类的时候先创建一个实例化对象）
    private static final Singletion singletion = new Singletion();//不管有没有需要，先实例化对象
    private Singletion(){}
    public static Singletion Get_New_singletion(){//对外提供对象的方法
        return singletion;
    }
}

    嗯这里只有五行代码，核心思路是在类加载的时候直接实例化对象。

    最后一种：内部类加载模式

    我们只需要把饿汉设计模式的单例类改成静态的内部类就行，先看代码

class OutClass {
    static class Singletion {//把单例类做成内部类，那么在外部类加载的时候就先不会实例化对象
        private static final Singletion singletion = new Singletion();
        private Singletion() {}
        public static Singletion Get_New_singletion() {
            return singletion;
        }
    }
}        

    这种设计方法的好处是：单例类(OutClass)加载的时候并不会加载内部静态类，只有在第一次引用（使用Get_New_singletion（））方法的时候才会加载。所以不管外部类加载了多少次，内部静态类只加载一次。所以这种设计模式可以避免高并发时创建多余的对象。实现了线程的安全。

        至此关于Java的单例模式我就总结到这里，如果有错误的话还请指出。