单例模式

1.单例模式

单例模式属于创建型模式，是创建对象的最佳方式
这种模式涉及到的一个单一的类，该类创建自己的对象，同时确保只有单个对象
这个类仅仅提供唯一对象访问方式，可以直接访问，不需要实例化对象

注意：	1.单例类只能有一个实例
		2.单例类必须自己给自己创建自己的唯一实例
		3.单例类必须给所有其他对象提供这一实例

1.单例模式主要思想：保证类中仅有一个实例，并且提供一个访问它的全局访问点
2.单例模式主要解决的问题：一个全局使用的类频繁的的创建和销毁
3.单例模式的使用场景：控制实例数目，节省系统资源的情况、生产唯一序列号、web计数器
4.关键思想：构造方法私有化
5.单例模式的优点：1)在内存中只有一个实例，减少内存开销，尤其是在频繁的创建和销毁实例的时候
2)避免对资源的多重占用
6.单例模式的缺点：1)没有接口
2)没有继承
3)与单一职责原则冲突
4)该类只关心内部逻辑，不关心外部如何实例化

1.1懒汉式

懒汉式：线程不安全
线程不安全严格意义上并不是单例模式，是用于理解单例模式的

package 懒汉式;

public class Singleton {
	private static Singleton instance;
	private Singleton(){
		System.out.println("Singleton的构造方法");
	}
	public static Singleton getinstance() {
		if(instance==null) {
			instance=new Singleton();
		}
		return instance;
	} 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton s=Singleton.getinstance();
		Singleton s2=Singleton.getinstance();
		System.out.println(s+"\n"+s2);
	}
}

输出结果：

Singleton的构造方法
懒汉式.Singleton@15db9742
懒汉式.Singleton@15db9742

这种情况对于普通调用似乎看不出什么问题，并且确实只创建了一个对象，调用了两次getinstance()，但是我们说过这个是基于线程不安全的

package 懒汉式;

class Singleton {
	private static Singleton instance;
	private Singleton(){
		System.out.println("Singleton的构造方法");
	}
	public static Singleton getinstance() {
		if(instance==null) {
			instance=new Singleton();
		}
		return instance;
	} 
}

package 懒汉式;

public class ThreadMain implements Runnable{

	public static void main(String[] args) {
		ThreadMain tm=new ThreadMain();
		ThreadMain tm1=new ThreadMain();
		Thread t=new Thread(tm1);
		Thread t1=new Thread(tm);
		t1.start();
		t.start();
	}

	@Override
	public void run() {
		Singleton s=Singleton.getinstance();
		System.out.println(s);
	}

}

输出结果：

Singleton的构造方法
Singleton的构造方法
懒汉式.Singleton@44ead434
懒汉式.Singleton@741102c

这个时候的运行结果就不再是创建一次对象了，这个时候一个线程进入Singleton类调用构造方法，另一个线程也进去调用构造方法，这样就产生了线程不安全，谁都可以进去访问，单例不单例有关系吗？所以这种情况的单例模式实际上只是用于理解单例的，很少使用

懒汉式：线程安全
线程安全是因为加了锁，保证单例
优点：第一次调用才初始化，避免造成浪费
缺点：必须加锁synchronized才能保证单例，但是加锁会影响效率

class Singleton1 {
	private static Singleton1 instance;
	private Singleton1(){
		System.out.println("Singleton的构造方法");
	}
	public static synchronized Singleton1 getinstance() {
		if(instance==null) {
			instance=new Singleton1();
		}
		return instance;
	} 
}

public class ThreadMain implements Runnable{
	public static void main(String[] args) {
		ThreadMain tm=new ThreadMain();
		ThreadMain tm1=new ThreadMain();
		Thread t=new Thread(tm1);
		Thread t1=new Thread(tm);
		t1.start();
		t.start();
	}
	@Override
	public void run() {
		Singleton1 s=Singleton1.getinstance();
		System.out.println(s);
	}

}

输出结果：

Singleton的构造方法
懒汉式.Singleton1@741102c
懒汉式.Singleton1@741102c

我们发现又正常了，因为我们加了synchronized实现了锁机制
懒汉式这个名称主要是由于这个模式是要用的时候就创建，不用就不创建，比较像懒汉一样，不管外面怎么乱糟糟，我只要是想用就用

1.2饿汉式

饿汉式是基于类加载机制实现的，避免了多线程的同步问题，不过，instance在类加载的时候就实例化了，大多数的单例都是调用getInstance方法
优点：没有加锁，执行效率高
缺点：类加载时就初始化，浪费内存，容易产生垃圾

package 饿汉式;

public class Singleton2 {
	private static Singleton2 instance=new Singleton2();
	private Singleton2(){
		System.out.println("Singleton2的构造方法");
	}
	public static Singleton2 getInstance() {
		return instance;
	}
}

package 饿汉式;

public class ThreadMain2 implements Runnable{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThreadMain2 tm=new ThreadMain2();
		ThreadMain2 tm1=new ThreadMain2();
		Thread t=new Thread(tm);
		Thread t1=new Thread(tm1);
		t1.start();
		t.start();
	}

	@Override
	public void run() {
		Singleton2 s=Singleton2.getInstance();
		System.out.println(s);
	}
}

输出结果：

Singleton2的构造方法
饿汉式.Singleton2@741102c
饿汉式.Singleton2@741102c

因为它在类加载的时候就创建了对象，所以也叫饿汉式

1.3双检锁(双重校验锁)模式

DCL模式(Double-checked locking)：采用双锁机制，线程安全，且双检锁机制可以大幅度降低synchronized带来的性能开销
多个线程在同一时间创建对象时，会通过加锁来保证只有一个线程来创建对象
对象创建好后，执行getInstance将不需要获取锁，直接返回已创建好的对象

package 双检锁模式;

public class Singleton3 {
	private volatile static Singleton3 instance;
	private Singleton3() {
		System.out.println("构造方法");
	}
	public static Singleton3 getInstance() {
		if(instance==null) {
			synchronized (Singleton3.class) {
				if(instance==null) {
					instance=new Singleton3();
				}
			}
		}
		return instance;
	}
}

package 双检锁模式;

public class ThreadMain3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton3 s3=Singleton3.getInstance();
		Singleton3 s4=Singleton3.getInstance();
		System.out.println(s3+"\n"+s4);
	}
}

1.4登记模式(静态内部类模式)重点

这种方式能达到双检锁方式相同的功效，但是实现要更简单，对静态域使用延迟初始化，应该使用这种方式而不是双检锁方式
这种方式同样利用classloader机制来保证初始化instance时只有一个线程

静态内部类模式和双检锁模式的区别：
1.双检锁只要Singleton类被加载了，那么instance就会被实例化，而静态内部类模式是Singleton类被加载了不一定被初始化，因为Singleton类没有被主动使用，只是通过显示调用getInstance方法时，才会显示加载Singleton类，从而实例化instance 

package 登记模式;

public class Singleton4 {
	private static class SingletonHolder{
		private static final Singleton4 INSTANCE=new Singleton4();
	}
	private Singleton4() {
		System.out.println("构造方法");
	}
	public static final Singleton4 getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

package 登记模式;

public class ThreadMain4 {

	public static void main(String[] args) {
		Singleton4 s4=Singleton4.getInstance();
		Singleton4 s5=Singleton4.getInstance();
		System.out.println(s4+"\n"+s5);

	}
}

输出结果：

构造方法
登记模式.Singleton4@15db9742
登记模式.Singleton4@15db9742