注明：文中内容参考来自书籍《Java多线程编程核心技术》第六章
1）懒汉模式：以下代码是完全错误的，线程不安全。项目中写的代码大多属于这种情况，当不存在多线程访问时这种方式应该是可取的。
public static LazySingleton getInstance() {
try {
if (Instance != null) {
} else {
Thread.sleep(3000);
Instance = new LazySingleton();
}
} catch (InterruptedException exception) {
exception.printStackTrace();
}
return Instance;
}
1.1）针对懒汉模式解决方案1： geInstance声明synchronized关键字 ，整个方法上锁
但是因为是同步运行，必须等到上一个线程释放锁以后才能继续执行，所以效率低下
synchronized public static LazySingleton getInstance() {
try {
if (Instance != null) {
} else {
Thread.sleep(3000);
Instance = new LazySingleton();
}
} catch (InterruptedException exception) {
exception.printStackTrace();
}
return Instance;
}
1.2）针对懒汉模式解决方案2： 同步代码块 和方案1一样效率低下
public static LazySingleton getInstance() {
try {
synchronized(LazySingleton.class){
if (Instance != null) {
} else {
Thread.sleep(3000);
Instance = new LazySingleton();
}
}
} catch (InterruptedException exception) {
exception.printStackTrace();
}
return Instance;
}
1.3）懒汉模式解决方案3： 针对重要代码进行单独同步，然并卵
public static LazySingleton getInstance() {
try {
if (Instance != null) {
} else {
Thread.sleep(3000);
//然并卵，两个不同的线程，仍然会让代码跑到这里，当第一个线程释放锁后，Instance=new LazySingleton()
//会再次执行，就出现两个实例对象
synchronized (LazySingleton.class) {
Instance = new LazySingleton();
}
}
} catch (InterruptedException exception) {
exception.printStackTrace();
}
return Instance;
}
1.4）懒汉模式解决方案4：使用DCL双检查锁机制(双重检查Double-Check Locking)，大多数多线程结合单例使用的解决方案
public static LazySingleton getInstance() {
try {
if (Instance != null) {
} else {
Thread.sleep(3000);
//既保证了不需要同步代码的异步执行性，有保证了单例效果
//书中的同步代码的异步执行性这样的描述没懂？？？
synchronized (LazySingleton.class) {
//保证进入这块代码是异步，如果已经实例化，则不再执行初始化代码
if (Instance==null) {
Instance = new LazySingleton();
}
}
}
} catch (InterruptedException exception) {
exception.printStackTrace();
}
return Instance;
}
2)饿汉模式：书中说getInstance()没有同步 存在线程安全问题，但是在getInstance加了线程休眠，依然hasCode输出一致，所以还没想明白。
public class HungrySingleton implements Serializable{
/**
* 不能有其他实例变量
*/
private static HungrySingleton Instance = new HungrySingleton();
public static HungrySingleton getInstance() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return Instance;
}
}
3）静态内置类实现单例模式
public class StaticInnerSingleton {
/*
* 静态内之类实现单例模式
*/
private static class SingletonObject {
private static StaticInnerSingleton Instance = new StaticInnerSingleton();
}
private String content;
private StaticInnerSingleton() {
}
public static StaticInnerSingleton getInstance(String content) {
SingletonObject.Instance.setContent(content);
return SingletonObject.Instance;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
System.out.println(String.valueOf(super.hashCode()) + ": " + this.content);
return super.hashCode();
}
}
- 序列化和反序列化的单例模式实现：书中代码是反序列化增加了readResolve 的实现。但是书中是用的protected 关键字修饰，然并卵。然后网址搜索了一篇文章，换成private修饰OK。附上链接[http://www.cnblogs.com/kakafra/archive/2012/10/26/2740436.html]
public class SeriealSingleton implements Serializable{
private static final long serialVersionUID = -4994911035515393248L;
private static class SingletonObject{
private static final SeriealSingleton Instance = new SeriealSingleton();
}
private SeriealSingleton() {
// TODO Auto-generated constructor stub
}
public static SeriealSingleton getInstance(){
return SingletonObject.Instance;
}
//如果这段代码注释掉，则还是多例 ，书中代码是用protected 修饰这个代码，还是多例模式
//网上搜到这边文章http://www.cnblogs.com/kakafra/archive/2012/10/26/2740436.html
//改为private 就是单例了。
private Object readResolve() throws ObjectStreamException{
System.out.println("调用了readResolve方法");
return SingletonObject.Instance;
}
}
- static代码块实现单例模式
public class StaticBlockSingleton {
private static StaticBlockSingleton Instance = null;
private StaticBlockSingleton() {
}
/*
* 静态代码块在使用来的时候已经执行
*/
static{
Instance = new StaticBlockSingleton();
}
public static StaticBlockSingleton getInstance() {
return Instance;
}
}
- enum枚举数据类型实现单例模式：应该很少会这样写吧。
public enum EnumSingleton {
connectionFactory;
private Connection connection;
/*
* 枚举enum和静态代码块特性相似，使用枚举时，构造方法会被自动调用
* 但是却暴漏了枚举类，违反职责单一原则
* EnumBetterSingleton
*/
private EnumSingleton() {
try {
System.out.println("Enum Singleton Contructor");
String url = "jdbc:sqlserver://";
String username = "sa";
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;
}
}
enum枚举数据类型实现单例模式更好的实现方式：
public class EnumBetterSingleton {
public enum SelfEnumSingleton {
connectionFactory;
private Connection connection;
private SelfEnumSingleton() {
try {
System.out.println("Enum Singleton Contructor");
String url = "jdbc:sqlserver://";
String username = "sa";
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 SelfEnumSingleton.connectionFactory.getConnection();
}
}
综上，关于单例模式总结结束。
源码地址：[https://github.com/chaozaiai/JavaTrain/tree/master/javamultithreading/chapter06]
本文做一下补充1：
书上的DCL双重检查所机制是正确的，因为书中增加了volatile关键字，保证了instance = new SingletonClass() 在java jdk 5 版本及更新的版本，这句代码不会被重排序，这样的DCL是有效的。因为看了一篇文章，讲无用的DCL。却没有仔细对比书中的源码和文章中的不同。文中最后提到的其中一种方案就是加volatile关键字。只是《Java多线程编程核心技术》并没有强调volatile的重要性。《Java并发编程的艺术》第三章3.8节更细致的讲到了这个问题。
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html