1、概念：
单例模式(Singleton)：又叫单态模式，它出现的目的是为了保证一个类在系统中只有一个实例，并提供一个访问它的全局访问点。即：为了可以保证系统中一个类只有一个实例而且该实例又易于外界访问，从而方便对实例个数的控制并节约系统资源而出现的解决方案；
2、应用场景：
2.1、有频繁实例化然后销毁的情况，也就是频繁的 new 对象，可以考虑单例模式；
2.2、创建对象时耗时过多或者耗资源过多，但又经常用到的对象；
2.3、频繁访问 IO 资源的对象，例如数据库连接池或访问本地文件；
3、线程安全的单例模式
3.1 静态内部类模式：
public class Singleton{
// 无参构造器
private Singleton(){
}
// 静态内部类
private static class Innerclass{
private static final Singleton SINGLETON = new Singleton();
}
public Singleton getInstance(){
return Innerclass.SINGLETON
}
}3.2 双重检查锁:
public class Singleton{
// 静态可见的实例
private static volatile Singleton instance = null;
// 无参构造器
private Singleton(){}
public Singleton getInstance(){
if(instance == null){
synchronized(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance ;
}
}4、五种单例示例
package org.sw.single;
/**
* 单例模式
*
* @Description: TODO
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
/**
* 饿汉式
*
* @Description: TODO
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
/**
* 懒汉式
*
* @Description: TODO
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class LazySingleton {
private static LazySingleton lazySingleton;
private LazySingleton() {
}
private static LazySingleton getInstance() {
if (null == lazySingleton) {
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
/**
* 多线程下线程安全的懒汉式单例
*
* @Description: 1 同步延迟加载 — synchronized方法
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class MultiThreadSingleton {
private static MultiThreadSingleton instance;
private MultiThreadSingleton() {
}
public static synchronized MultiThreadSingleton getInstance() {
if (null == instance) {
instance = new MultiThreadSingleton();
}
return instance;
}
}
/**
* 多线程下线程安全的懒汉式单例
*
* @Description: 2 同步延迟加载 — synchronized块
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class BlockSingle {
private static BlockSingle instance;
private BlockSingle() {
}
private static BlockSingle getInstance() {
// 使用 synchronized 块，临界资源的同步互斥访问
synchronized (BlockSingle.class) {
if (null == instance) {
instance = new BlockSingle();
}
}
return instance;
}
}
/**
* 多线程下线程安全的懒汉式单例
*
* @Description: 3 同步延迟加载 — 使用内部类实现延迟加载
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class InterClassSingleton {
private InterClassSingleton() {
}
private static class InterClass {
private static InterClassSingleton instance = new InterClassSingleton();
}
private static InterClassSingleton getInstance() {
return InterClass.instance;
}
}
/**
* 多线程下线程安全的懒汉式单例
*
* @Description: 4 双重检测（线程安全的懒汉式单例）
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class DoubleCheckSingleton {
private static DoubleCheckSingleton instance;
private DoubleCheckSingleton() {
}
private static DoubleCheckSingleton getInstance() {
// Double.Check idiom
if (null == instance) {
synchronized (DoubleCheckSingleton.class) {
if (null == instance) {
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
/**
* 多线程下线程安全的懒汉式单例
*
* @Description: 5 ThreadLocal
* @author liangsw
* @date 2019-07-22
* @version 1.0v
*/
class ThreadLocalSingleton {
// ThreadLocal 线程局部变量,将单例instance线程私有化
private static ThreadLocal<ThreadLocalSingleton> threadLocal = new ThreadLocal<ThreadLocalSingleton>();
private static ThreadLocalSingleton instance;
private ThreadLocalSingleton() {
}
private static ThreadLocalSingleton getInstance() {
if (threadLocal.get() == null) {
synchronized (ThreadLocalSingleton.class) {
if (instance == null) {
instance = new ThreadLocalSingleton();
}
}
threadLocal.set(instance);
}
return threadLocal.get();
}
}
