单例模式与多线程

　　单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

　　1.)某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

　　2.)省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

　　3.)有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程

　　

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

public class Singleton {
private Singleton(){
}

private static final Singleton singleton = new Singleton();

public static Singleton getInstance() {
return singleton;
}
}

public class Singleton {
/* 私有构造方法，防止被实例化 */
private Singleton() {
}

/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}

/* 获取实例 */
public static Singleton getInstance() {
return SingletonFactory.instance;
}

/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
public Object readResolve() {
return getInstance();
}
}

自定义线程

public class MyThread extends Thread {
@Override
public void run() {
System.out.println(Singleton.getInstance().hashCode());
}
}
public class Run {
public static void main(String[] args) throws ParseException {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}

1756075494

1756075494

1756075494

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

　　静态内置类可以达到线程安全问题，但如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。

public class Singleton implements Serializable{
/* 私有构造方法，防止被实例化 */
private Singleton() {
}

/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}

/* 获取实例 */
public static Singleton getInstance() {
return SingletonFactory.instance;
}

/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
protected Object readResolve() throws ObjectStreamException{
System.out.println("调用了readResolve方法");
return getInstance();
}
}

创建业务类SaveAndRead，代码如下：

public class SaveAndRead {
public static void main(String[] args)  {
try {
Singleton singleton = Singleton.getInstance();
FileOutputStream fosRef = new FileOutputStream(new File("mySingletonFIle.txt"));
ObjectOutputStream oosRef = new ObjectOutputStream(fosRef);
oosRef.writeObject(singleton);

oosRef.close();
fosRef.close();
System.out.println(singleton.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

try{
FileInputStream fisRef = new FileInputStream(new File("mySingletonFIle.txt"));
ObjectInputStream iosRef = new ObjectInputStream(fisRef);
Singleton singleton = (Singleton) iosRef.readObject();
iosRef.close();
fisRef.close();
System.out.println(singleton.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}

723635264

调用了readResolve方法

723635264

如果把Singleton类里的readResolve方法注释掉，则结果会是这样的

1484511730

588729095

不是同一个对象

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

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

public class Singleton {
/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
private static Singleton instance = null;

/* 私有构造方法，防止被实例化 */
private Singleton() {
}

static {
instance = new Singleton();
}

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

自定义线程MyThread和Run类不变，结果如下：

1032010069

1032010069

1032010069

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

　　枚举enum和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，也可以应用其这个特性实现单例设计模式，最经典的就是数据库连接。

public class Singleton {
// 枚举类要放单例里防止暴露，不然就违反了“职责单一原则”
public enum MySingleton {
connectionFactory;
private Connection connection;

private MySingleton() {
try {
System.out.print("调用了Singleton的构造！");
String url = "jdbc:sqlserver://localhost:1079;databaseNme=DB";
String username = "123456";
String password = "123456";
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 MySingleton.connectionFactory.getConnection();
}
}