设计模式初探——单例模式

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_40301026/article/details/88943084

所谓的单例模式就是指的一个类只提供一个对象实例,而且所提供的实例只有一个访问的入口(方法)。

常见的应用场景:

  • Windows的任务管理器
  • Windows的回收站
  • 项目中,读取配置文件的类,一般也只有一个对象。
  • 数据库连接池的设计等等。

常见的有五种实现方式:

  • 饿汉式

         所谓的饿汉式就是,让单例对象在类创建时就被加载,像一个饿汉。

package cn.liu.single;
/**
 * 饿汉式单例模式
 * @author Administrator
 *
 */
public class Demo01 {
	//1.私有化静态属性
	//类初始化时,立即加载这个对象(没有延时加载的优势)。加载类时,天然的是线程安全的!
	private static Demo01 instance = new Demo01();
	//2.私有化构造器
	private  Demo01() {};
	//3.提供方法获得属性
	//方法没有同步,调用效率高!
	public static Demo01 getInstance() {
		return instance;
	}
}

 饿汉式特点:

  1. 它的静态属性直接new了一个对象。这样类在被加载时就直接new一个对象,之后可以反复的获得。(调用效率高)
  2. 线程安全
  • 懒汉式
package cn.liu.single;

/**
 * 懒汉式
 * @author Administrator
 *
 */
public class Demo02 {
	//1.私有化静态属性
	//类初始化时,不初始化这个对象(延时加载,真正用的时候再创建)。
	private static Demo02 instance ;
	//2.私有化构造器
	private Demo02() {};
	//3.提供静态方法获得属性
	//方法同步,调用效率低!
	public static synchronized Demo02 getInstance() {
		if(instance==null) {
			instance=new Demo02();
		}
		return instance;
	}
}

懒汉式特点:

  1. 在用的时候再去new对象,之后对象存在便可直接调用(也就是可以延时加载)
  2. 线程安全
  3. 调用效率不高
  • 双重锁
package cn.liu.single;
/**
 * 双重检查锁实现单例模式
 * @author Administrator
 *
 */
public class Demo03 {
private static Demo03 instance = null; 

  public static Demo03 getInstance() { 
    if (instance == null) { 
    	Demo03 sc; 
      synchronized (Demo03.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (Demo03.class) { 
            if(sc == null) { 
              sc = new Demo03(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 

  private Demo03() { 

  } 
}
  • 静态内部类实现
package cn.liu.single;
/**
 *静态内部类实现单例模式
 *线程安全。调用高效率高,实现了延迟加载
 * @author Administrator
 *
 */
public class Demo04 {
	//1.静态内部类
	private static class Singlepattern{
		private static final Demo04 instance = new Demo04();
	}
	//2.私有静态方法
	private Demo04() {}
	//3.获得单例对象
	public static Demo04 getInstance() {
		return Singlepattern.instance;
	}
}

特点:

  1. new对象使用静态内部类实现了,不会初始化类时调用此静态类,而是在其方法getInstance调用时才new。(延迟加载)
  2. 线程安全
  3. 和饿汉式一样代用效率高 
  • 枚举实现饿汉式
package cn.liu.single;
/**
 * 枚举实现单例模式
 * @author Administrator
 *
 */
public enum Demo05 {
	//这个枚举元素,本身就是单例对象
	INSTANCE;
	//添加自己需要的操作
	public void singleOperation() {
		
	}
	
}

特点:

  1. 线程安全
  2. 调用效率高
  3. 不能延时加载
  4. 可以天然防止反射和反序列化 

猜你喜欢

转载自blog.csdn.net/qq_40301026/article/details/88943084