Java多线程编程核心技术---单例模式与多线程

立即加载/饿汉模式

立即加载就是使用类的时候已经将对象创建完毕。

public class MyObject {    //立即加载方式==饿汉模式    private static MyObject myObject = new MyObject();    private MyObject(){    }    public static MyObject getInstance(){        //立即加载        //缺点是不能有其他实例变量        //getInstance()方法没有同步，有可能出现非线程安全问题        return myObject;    }}public class MyThread extends Thread {    @Override    public void run() {        System.out.println(MyObject.getInstance().hashCode());    }}public class Main {    public static void main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        t1.start();        t2.start();        t3.start();    }}

运行程序，控制台打印结果如下：

179547847217954784721795478472

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

---

延迟加载/懒汉模式

延迟加载就是在调用get()方法时实例才被创建

public class MyObject {    private static MyObject myObject;    private MyObject(){    }    public static MyObject getInstance() {        //延迟加载        if (myObject != null) {            return myObject;        }        myObject = new MyObject();        return myObject;    }}public class MyThread extends Thread {    @Override    public void run() {        System.out.println(MyObject.getInstance().hashCode());    }}public class Main {    public static void main(String[] args) {        MyThread t1 = new MyThread();        t1.start();    }}

程序运行结果如下：

1396452035

此实验虽然取得一个对象的实例，但是如果是在多线程环境中，就会出现取出多个实例的情况。对以上代码中的main函数做如下修改：

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

重新运行程序，控制台打印结果如下：

16647126017954784721858758426

控制台打印了三个不同的hashCode，说明并没有实现单例模式。

---

延迟加载/懒汉模式 解决方案

public class MyObject {    private static MyObject myObject;    private MyObject(){    }    //整个方法上锁，效率较低    synchronized public static MyObject getInstance() {        //延迟加载        if (myObject != null) {            return myObject;        }        try {        //模拟一些耗时操作                Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        myObject = new MyObject();        return myObject;    }}

重新运行程序，控制台将打印出三个一样的hashCode。

以上方法对整个方法加锁，效率比较低。对以上代码做如下修改：

public class MyObject {    private static MyObject myObject;    private MyObject(){    }    public static MyObject getInstance() {        //延迟加载        if (myObject != null) {            return myObject;        }        try {            //模拟一个耗时操作            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        synchronized (MyObject.class) {            myObject = new MyObject();        }        return myObject;    }}

重新运行程序，控制台打印结果如下：

7740880256415026491367113803

以上代码虽然解决的效率问题，但是仍然没有保证只创建一个实例。继续对以上代码做如下修改：

public class MyObject {    private static MyObject myObject;    private MyObject(){    }    public static MyObject getInstance() {        //延迟加载        if (myObject != null) {            return myObject;        }        try {            //模拟一个耗时操作            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        synchronized (MyObject.class) {            if (myObject == null) {                myObject = new MyObject();            }        }        return myObject;    }}

重新运行程序，控制台输入结果如下：

641502649641502649641502649

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

---

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

public class MyObject {    private static class MyObjectHandler{        private static MyObject myObject = new MyObject();    }    private MyObject(){            }    public static MyObject getInstance () {        return MyObjectHandler.myObject;    }}

运行程序，控制台输出结果如下：

774088025774088025774088025

---

序列化与反序列化的单例模式实现

public class MyObject implements Serializable {    private static final long serialVersionUID = 1L;    private static class MyObjectHandler{        private static MyObject myObject = new MyObject();    }    private MyObject(){            }    public static MyObject getInstance () {        return MyObjectHandler.myObject;    }}public class SaveAndRead {    public static void main(String[] args) {        try {//序列化对象到磁盘            MyObject myObject = MyObject.getInstance();            FileOutputStream fileOutputStream = new FileOutputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));            ObjectOutputStream objectOutput = new ObjectOutputStream(fileOutputStream);            objectOutput.writeObject(myObject);            objectOutput.close();            fileOutputStream.close();            System.out.println(myObject.hashCode());        } catch (Exception e) {            e.printStackTrace();        }        /****************/        try {//从磁盘反序列化到对象            FileInputStream fileInputStream = new FileInputStream(new File("/Users/shangyidong/Downloads/myObjectFile.txt"));            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);            MyObject myObject = (MyObject) objectInputStream.readObject();            objectInputStream.close();            fileInputStream.close();            System.out.println(myObject.hashCode());        } catch (Exception e) {            e.printStackTrace();        }    }}

运行程序，控制台打印结果如下：

9884877391878277481

控制台打印出的hashCode不同，存储到磁盘上的对象和从磁盘读取出来的对象并不是同一个对象。对以上代码做如下修改：

public class MyObject implements Serializable {    private static final long serialVersionUID = 1L;    private static class MyObjectHandler{        private static MyObject myObject = new MyObject();    }    private MyObject(){            }    public static MyObject getInstance () {        return MyObjectHandler.myObject;    }    protected Object readResolve(){        System.out.println("readResolve invoked");        return MyObjectHandler.myObject;    }}

重新运行程序，控制台打印结果如下：

1066557918readResolve invoked1066557918

反序列化时使用了ReadResolve()方法，存储到磁盘上的对象和从磁盘上取出来的对象是同一个对象。

---

使用static代码块实现单例模式

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

public class MyObject {    private static MyObject myObject = null;    private MyObject(){            }    static{        myObject = new MyObject();    }    public static MyObject getInstance() {        return myObject;    }}public class MyThread extends Thread {    @Override    public void run() {        for (int i = 0; i < 3; i++) {            System.out.println(MyObject.getInstance().hashCode());        }    }}public class Main {    public static void main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        t1.start();        t2.start();        t3.start();    }}

运行程序，控制台输出结果如下：

708252873708252873708252873708252873708252873708252873708252873708252873708252873

---

使用enum枚举数据类型实现单例模式

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

public enum MyObject {    connectionFactory;    private Connection connection;    private MyObject(){        try {            System.out.println("创建MyObject对象");            String url = "jdbc:mysql://127.0.0.1:3306/test";            String user = "root";             String password = "";            String driver = "com.mysql.jdbc.Driver";            Class.forName(driver);            connection = DriverManager.getConnection(url, user, password);        } catch (Exception e) {            e.printStackTrace();        }    }    public Connection getConnection() {        return connection;    }}public class MyThread extends Thread {    @Override    public void run() {        for (int i = 0; i < 3; i++) {            System.out.println(MyObject.connectionFactory.getConnection().hashCode());        }    }}public class Main {    public static void main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        t1.start();        t2.start();        t3.start();    }}

运行程序，控制台打印结果如下：

创建MyObject对象125319592812531959281253195928125319592812531959281253195928125319592812531959281253195928

---

完善使用enum枚举实现单例模式

上面的代码中将枚举类进行了暴露，违反了“职责单一原则”。下面进行改善：

public class MyObject {    public enum MyEnumSingleton{        connectionFactory;        private Connection connection;        private MyEnumSingleton(){            try {                System.out.println("创建MyObject对象");                String url = "jdbc:mysql://127.0.0.1:3306/test";                String user = "root";                 String password = "";                String driver = "com.mysql.jdbc.Driver";                Class.forName(driver);                connection = DriverManager.getConnection(url, user, password);            } catch (Exception e) {                e.printStackTrace();            }        }        public Connection getConnection() {            return connection;        }       }    public static Connection getConnection() {        return MyEnumSingleton.connectionFactory.getConnection();    }}public class MyThread extends Thread {    @Override    public void run() {        for (int i = 0; i < 3; i++) {            System.out.println(MyObject.getConnection().hashCode());        }    }}public class Main {    public static void main(String[] args) {        MyThread t1 = new MyThread();        MyThread t2 = new MyThread();        MyThread t3 = new MyThread();        t1.start();        t2.start();        t3.start();    }}

程序运行结果如下：

创建MyObject对象203998848020399884802039988480203998848020399884802039988480203998848020399884802039988480