单例模式的多种写法

单例模式

前言

刚接触设计模式，我认为设计模式它是一种代码编程长期发展的经验和套路，能够优化我们的代码。现有的设计模式有23种。这次我说学习的是单例模式

单例模式的定义

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模
式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提
供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

原理
单例模式的类中有且仅有一个实例被创建，其他的类要使用单例对象时都要通过这个类提供的特殊渠道来进行获取。

单例模式的优点

• 单例模式可以保证内存里只有一个实例，减少了内存的开销。
• 可以避免对资源的多重占用。
• 单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点

• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

单例模式的适用范围

1、需要频繁实例化然后销毁的对象。
2、创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3、有状态的工具类对象。
4、频繁访问数据库或文件的对象。

单例模式的姿态写法

1.饿汉(静态常量)

@Test 测试类
public class Text {
	public static void main(String[] args){
		SingLetenEHan ehan1=SingLetenEHan.newSingLetenEHan();
		SingLetenEHan ehan2=SingLetenEHan.newSingLetenEHan();
		System.out.println(ehan1==ehan2); //是否都是同一个对象
		System.out.println(ehan1.hashCode()); //输出两个对象的hashCode进行比较
		System.out.println(ehan2.hashCode());
	}
}

public class SingLetenEHan {
//	创建一个静态的初始化对象
	private  static SingLetenEHan s=new SingLetenEHan();
	//构造方法私有化
	SingLetenEHan(){}
	//用方法返回创建好的对象
	public static SingLetenEHan newSingLetenEHan(){
		 return s;
	}
}




/*优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费

结论：这种单例模式可用，可能造成内存浪费
*/

代码的执行顺序

//代码块优先于构造方法执行 所以可以把对象的创建放到静态代码块中
	//构造方法私有化
	private SingLetenEHan(){}
//	创建一个初始化空对象
	private  static SingLetenEHan s=null;
	static{
		s=new SingLetenEHan();
	}
	//用方法返回对象
	public static SingLetenEHan newSingLetenEHan(){
		 return s;
	}
}

两者的执行结果都是：

2.懒汉（线程不安全）

此方式在使用时才会创建对象不会造成资源浪费

//懒汉单例模式
public class SingLetenLanHan {
	//创建一个私立化默认空对象
	private static SingLetenLanHan s=null;
	//私立化构造方法
	private SingLetenLanHan(){}
	//创建一个静态方法提供对象的创建
	public static  SingLetenLanHan newSingLetenLanHan(){
		if(s==null){
			s=new SingLetenLanHan();
		}
		return s;
	}
}

if(s==null){}
在多线程中if判断同时可能会进入多个，
对象就不是之创建一个，故而就不是单例模式了

3.懒汉（线程同步–安全synchronized ）

//懒汉单例模式
public class SingLetenLanHan {
	//单例模式--懒汉
	private static SingLetenLanHan s=null;
	private SingLetenLanHan(){}
		//方法上加   synchronized  线程同步
	public static synchronized SingLetenLanHan newSingLetenLanHan(){
		if(s==null){
			s=new SingLetenLanHan();
		}
		return s;
	}
}
//在方法上加上线程同步关键字synchronized
//从而达到线程安全，不过在多线程模式下，此方法效率低下

4.懒汉（线程同步–安全volatile）

package DanLiMoShi;
//懒汉单例模式
public class SingLetenLanHan {
	//单例模式--懒汉
	//不安全   实例上加 volatile
	private static volatile SingLetenLanHan s=null;
	private SingLetenLanHan(){}
	public static  SingLetenLanHan newSingLetenLanHan(){
		if(s==null){
			s=new SingLetenLanHan();
		}
		return s;
	}
}

volatile是轻量级同步机制。在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，是一种比synchronized关键字更轻量级的同步机制。
volatile屏蔽掉了JVM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

5.懒汉（线程安全–同步代码块）

//懒汉单例模式
public class SingLetenLanHan {
	//单例模式--懒汉
	//不安全   实例上加 volatile
	//方法上加   synchronized
	private static SingLetenLanHan s=null;
	private SingLetenLanHan(){}
	public static  SingLetenLanHan newSingLetenLanHan(){
		if(s==null){
			synchronized (SingLetenLanHan.class) {
				s=new SingLetenLanHan();
			}
		}
		return s;
	}
}

懒汉式(线程安全，同步代码块)

优缺点说明:
1)这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
2）但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例
3）结论:在实际开发中，不能使用这种方式

6、懒汉式（线程安全、双重检查）

public class LazyTest1 {

	public static void main(String[] args) {
		System.out.println("懒加载的双重锁、双重检查、线程安全");
	Singleton s1 =	Singleton.getSingleton();
	Singleton s2 =	Singleton.getSingleton();
	
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	}
}
class Singleton{
	private Singleton() {
	}
	private static volatile Singleton singleton = null;
	//提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用

	public static Singleton getSingleton() {
		if (singleton==null) {
			synchronized (Singleton.class) {
				if (singleton==null) {
					singleton=new Singleton();
				}
			}
		}	
		return singleton;
	}
}

 优缺点说明：

1. Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
2. 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
3. 线程安全；延迟加载；效率较高
4. 结论：在实际开发中，推荐使用这种单例设计模式

7、静态内部类

public class LazyTest1 {

	public static void main(String[] args) {
		System.out.println("静态内部类实现单例模式");
	Singleton s1 =	Singleton.getSingleton();
	Singleton s2 =	Singleton.getSingleton();
	
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	}
}
//静态内部类
class Singleton{
	//构造器私有化
	private Singleton() {
		
	}
	//静态内部类   类中有一个静态属性
	private static class SingleTon{
		private static  Singleton INSTANCE = new Singleton();
	}
		//提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
	public static Singleton getSingleton() {		
		return SingleTon.INSTANCE;
	}
}

 优缺点说明：

1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

2. 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。

3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

5. 结论：推荐使用.

8、通过枚举的方式实现单例模式

public class SingletonEnum {

	public static void main(String[] args) {
		
	Singleton s1 = 	Singleton.INSTANCE;
	Singleton s2 = 	Singleton.INSTANCE;
	System.out.println(s1==s2);
	System.out.println(s1.hashCode());
	System.out.println(s2.hashCode());
	
	}
}
//通过枚举的方式实现单例模式
enum Singleton{
	INSTANCE;	
	public void say() {
		System.out.println("i  am  ok");
	}
}

 优缺点说明：

1. 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2. 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
3. 结论：推荐使用

单例模式注意事项和细节说明

• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。
• 单例模式创建对象需要调用方法而不是去new
• 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等

一到四为自我学习总结
第五到八种方法借鉴于：