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();
}
}

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

1795478472
1795478472
1795478472

控制台打印的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();
}
}

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

166471260
1795478472
1858758426

控制台打印了三个不同的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;
}
}

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

774088025
641502649
1367113803

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

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;
}
}

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

641502649
641502649
641502649

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

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

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

}
public static MyObject getInstance () {
return MyObjectHandler.myObject;
}
}

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

774088025
774088025
774088025

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

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();
}
}
}

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

988487739
1878277481

控制台打印出的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;
}
}

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

1066557918
readResolve invoked
1066557918

反序列化时使用了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();
}
}

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

708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873
708252873

使用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对象
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928
1253195928

完善使用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对象
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480
2039988480