23种设计模式之单例模式
单例模式分为: 饿汉式 懒汉式 双重锁懒汉式 静态懒汉式 静态内部类懒汉式 枚举懒汉式
单例模式饿汉式
class SingletonTest01{
public static void main(String [] args){
//测试
Singleton inSingleton = Singleton.getInstance();
Singleton inSingleton2 = Singleton.getInstance();
System.out.println(inSingleton == inSingleton2);//true
System.out.println(inSingleton.hashCode());//hashCode相同
System.out.println(inSingleton2.hashCode());
}
}
class Singleton{
//1.构造器私有化，外部不能通过new来创建对象
private Singleton(){}
//2.本类内部创建对象实例在类加载的时候就会被创建,这里使用final是保证线程安全，final不可变对象
private final static Singleton instance = new Singleton();
//3.提供一个公有的静态方法，返回实例对象，通过调用方法来返回实例对象
public static Singleton getInstance() {
return instance;
}
}
//输出
true
366712642
366712642
结论：
构造器私有化，外部不能通过new来实例化对象，通过getInstance方法来创建对象
优点：线程安全,以空间换取时间效率高
缺点：在类加载时对象被创建，会占用内存
单例模式懒汉式
class SingletonTest02{
public static void main(String [] args){
// 测试
Singleton inSingleton = Singleton.getInstance();
Singleton inSingleton2 = Singleton.getInstance();
System.out.println(inSingleton == inSingleton2);// true
System.out.println(inSingleton.hashCode());// hashCode相同
System.out.println(inSingleton2.hashCode());
}
}
class Singleton{
//声明一个对象
private static Singleton instance;
//构造器私有化，外部不能通过new来创建对象
private Singleton(){}
//提供一个静态的公有方法，使用synchronize修饰加入同步处理的代码，线程安全
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
//输出
true
366712642
366712642
结论：
缺点：效率低，每个类在得到类的实例时候，执行getInstance（）方法都要进行同步。
优点：线程安全。
单例模式双重检查
class SingletonTest06{
public static void main(String [] args){
//测试
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);// true
System.out.println(instance.hashCode());// hashCode相同
System.out.println(instance2.hashCode());
}
}
//懒汉式（线程安全同步方法）
class Singleton{
//采用volatile修饰变量防止重序
private static volatile Singleton instance;
private Singleton(){}
//提供一个静态的公有方法，加入双重代码检查，解决线程安全问题，同时解决懒加载问题
public static Singleton getInstance(){
if(instance == null){
synchronized(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
//输出
true
366712642
366712642
结论:
该单例模式采用volatile、synchronized 进行双重检查，防止了因为多线程问题产生的重序。
很好的解决了线程安全性的问题，创建对象的时候实现了懒加载效果，当需要用到时返回instance创建实例。
单例模式静态内部类
class SingletonTest7{
public static void main(String [] args){
//测试
Singleton instance = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance == instance2);// true
System.out.println(instance.hashCode());// hashCode相同
System.out.println(instance2.hashCode());
}
}
class Singleton{
private Singleton(){}
//静态内部类，该类中有一个静态属性
private static class SingletonInstance{
//静态内部类可访问外部类的特性
private static final Singleton INSTANCE = new Singleton();
}
//提供一个静态公共方法，直接返回SingletonInstance.INSTANCE
public static Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
//输出
true
366712642
366712642
结论:
这种方式采用了类装在的机制来保证初始化实例时只有一个线程，静态内部类方式在Singleton类被装在时并不会立即实例化，而是在需要实例化时，调用getInstance（）方法，才会装载SingletonInstance类，从而完成Singleton的实例化，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
单例模式枚举的方式
public class SingletonTest08 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
Singleton instance2 = Singleton.INSTANCE;
System.out.println(instance == instance2);//true
System.out.println(instance.hashCode());
System.out.println(instance2.hashCode());
}
}
//枚举实现单例模式
enum Singleton{
INSTANCE;//属性
public void sayOK() {
System.out.println("ok");
}
}
//输出
true
366712642
366712642
结论
借助JDK1.5种添加的枚举来实现单例模式。
枚举在java中与普通类一样，都能拥有字段与方法，而且枚举实例创建是线程安全的，在任何情况下，它都是一个单例。不仅能避免多线程同步问题，而
且还能防止反序列化重新创建新的对象。
