5.单例模式与多线程

提要：

• 本章的知识点非常重要，通过单例模式与多线程技术相结合，在这个过程中能发现很多以前从未考虑过的情况，一些不良的程序设计方法如果应用在商业项目中，将会遇到非常大的麻烦。在学习本章时只需要考虑一件事情，那就是：如何使单例模式遇到多线程是安全的、正确的。

---

立即加载/”饿汉模式”
介绍:什么是立即加载？立即加载就是试试用类的时候已经将对象创建完毕，常见的实现办法就是直接new实例化。而立即加载从中文的语境来看，有”着急”、”急迫”的含义，所以也成为”饿汉模式”。立即加载/”饿汉模式”是在调用方法前，实例已经被创建了。

看个例子:

package chapter6.singleton_0.service;

public class MyObject {
    //立即加载方式 == 饿汉方式
    private static MyObject myObject = new MyObject();

    private MyObject(){}

    public static MyObject getInstance(){
        //此代码版本为立即加载
        //此版本代码的缺点是不能有其他实例变量
        //因为getInstance()方法没有同步
        //所以有可能出现非线程安全问题
        return myObject;
    }
}

import chapter6.singleton_0.service.MyObject;

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}

import chapter6.singleton_0.exthread.MyThread;

public class Run {
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

控制台打印的hashCode是用一个值，说明对象是同一个，也就实现了立即加载型单例设计模式。

延迟加载/”懒汉模式”
介绍:说明是延迟加载？延迟加载就是在调用get()方法时实例才被创建，常见的实现方法就是在get()方法中进行new实例化。而延迟加载从中文的语境来看，是”缓慢”、”不急迫”的含义，所以也称为”懒汉模式”。

使用DCL双检查锁机制

看个例子:

public class MyObject {

    private volatile static MyObject myObject;

    private MyObject(){}
    //使用双检测机制来解决问题，既保证了不需要同步代码的异步执行性
    //又保证了单例的效果

    public static MyObject getInstance(){
        try{
            if(myObject != null){

            }else{
                //模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                synchronized (MyObject.class){
                    if(myObject == null){
                        myObject = new MyObject();
                    }
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        return myObject;
    }
    //此版本的代码称为双重检查Double-Check Locking

}

import chapter6.singleton_0.service.MyObject;

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}

import chapter6.singleton_0.exthread.MyThread;

public class Run {
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

总结：使用双重检查锁功能，成功地解决了”懒汉模式”遇到多线程的问题。DCL也是大多数多线程结合单例模式使用的解决方案。


使用静态内置类实现单例模式

看个例子:

public class MyObject {
    //内部类方式
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }
    private MyObject(){}
    public static MyObject getInstance(){
        return MyObjectHandler.myObject;
    }
}

import chapter6.singleton_0.service.MyObject;

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}

import chapter6.singleton_0.exthread.MyThread;

public class Run {
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

使用static代码块实现单例模式
说明:静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性来实现单例设计模式。

看个例子:

public class MyObject{
    private static MyObject instance = null;

    private MyObject(){}
    static {
        instance = new MyObject();
    }

    public static MyObject getInstance(){
        return instance;
    }
}

import chapter6.singleton_0.service.MyObject;

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}

import chapter6.singleton_0.exthread.MyThread;

public class Run {
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果：

使用enum枚举数据类型实现单例模式
说明:枚举enum和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以应用其这个特性实现单例设计模式。

看个例子:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * Created by yongshan_ning on 2017/5/2.
 */
public class MyObject{
    public enum MyEnumSingleton{
        connectionFactory;
        private Connection connection;
        private MyEnumSingleton(){
            try{
                System.out.println("创建MyObject对象");
                String url = "jdbc:sqlserver://localhost:3306;databaseName=SSM";
                String username = "root";
                String password = "";
                String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
                Class.forName(driverName);
                connection = DriverManager.getConnection(url, username, password);
            }catch (ClassNotFoundException e){
                e.printStackTrace();
            }catch (SQLException e){
                e.printStackTrace();
            }
        }
        public Connection getConnection(){
            return connection;
        }
    }
    public static Connection getConnection(){
        return MyEnumSingleton.connectionFactory.getConnection();
    }

}

import chapter6.singleton_0.service.MyObject;

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(MyObject.getInstance().hashCode());
    }
}

import chapter6.singleton_0.exthread.MyThread;

public class Run {
    public static void main(String[] args){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}