【设计模式】单例模式Singleton(Java)

文章目录

  • 定义
  • 类图
  • Java经典实现
    • 懒汉Lazy Mode:
    • 饿汉Eager Mode:
  • 在饿汉下的多线程案例
  • 在懒汉下的多线程案例
  • 总结

定义

单例模式(单件模式)确保一个类只有一个实例,并提供一个全局访问点。——HeadFirst

单例模式通过过防止外部实例化和修改来控制创建的对象的数量。

关键点:

  • 私有构造函数,没有其他类可以实例化一个新对象。
  • 私有引用-没有外部修改。
  • Public static getInstance方法是唯一可以获取对象的地方。

问:为什么单例模式能确保实例独一无二?
答:因为单例模式没有公开的构造器,构造器是私有的,因此他人无法自己创建实例对象。而且他人想获取实例必须通过调用getInstance静态方法得到实例,实例也许是调用时创建的,也许是之前已经创建好的。

类图

【设计模式】单例模式Singleton(Java)_第1张图片

Java经典实现

私有构造器、一个静态方法、一个静态变量。

懒汉Lazy Mode:

public class Singleton{
    // 使用一个静态变量记录Stingleton的唯一实例
    private static Singleton uniqueInstance;
    // 这里是其他有用的实例化变量
    // 私有构造方法
    private Singleton(){} 

    public static Singleton getInstance(){
        if(uniqueInstance == null){
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
    // 其他有用的方法
}

饿汉Eager Mode:

public class Singleton2 {
    // 使用一个静态私有变量记录Stingleton的唯一实例
    private static Singleton2 uniqueInstance = new Singleton2();
    // 这里是其他有用的实例化变量
    // 私有构造方法
    private Singleton2(){}

    public static Singleton2 getInstance(){
        return uniqueInstance;
    }
    // 其他有用的方法
}

在饿汉下的多线程案例

单例类GlobalNum.java

public class GlobalNum {
     private static  GlobalNum gn=new GlobalNum();
     private int num=0;
     public static GlobalNum getInstance()
     {
    	 return gn;
     }
     public synchronized int getNum() //加锁
     {
    	 return ++num; //返回访问次数
     }
}

主方法SingleMain.java

class NumThread extends Thread{
	private String threadName;
	public NumThread(String name)
	{
		threadName=name;
	}
	public void run()
	{ 
		GlobalNum gnObj=GlobalNum.getInstance();
		for (int i = 0; i < 5; i++) {
			System.out.println(threadName+"第"+gnObj.getNum()+"次访问");
			try {
				this.sleep(1000);
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("错误");
			} 
		}
	}
}

public class SingleMain {
//测试单件模式
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        NumThread thread1=new NumThread("线程1");
        NumThread thread2=new NumThread("线程2");
        thread1.start();
        thread2.start();
	}
}

JDK8运行结果:

线程12次访问
线程21次访问
线程13次访问
线程24次访问
线程15次访问
线程26次访问
线程17次访问
线程28次访问
线程19次访问
线程210次访问

在懒汉下的多线程案例

getInstance方法添加synchronized关键字,防止不同线程创建多个实例对象从而违反单例模式。

public class GlobalNum {
     private static GlobalNum globalNum;
     private int num=0;
     // getInstance方法添加synchronized关键字,防止创建多个实例
     public static synchronized GlobalNum getInstance()
     {
    	 if(globalNum==null){
             globalNum = new GlobalNum();
             return globalNum;
         }
         return globalNum;
     }
     public synchronized int getNum() //加锁
     {
    	 return ++num; //返回访问次数
     }
}

主方法SingleMain.java

同上

输出结果:

线程11次访问
线程22次访问
线程14次访问
线程23次访问
线程16次访问
线程25次访问
线程17次访问
线程28次访问
线程19次访问
线程210次访问

如果上述getInstance不添加synchronized,则会造成输出:

线程11次访问
线程21次访问
线程12次访问
线程22次访问
线程13次访问
线程23次访问
线程14次访问
线程24次访问
线程15次访问
线程25次访问

—————————————
上述懒汉下的多线程案例虽然达到预想效果但是存在缺陷:为了防止多个线程创建多个对象,给getInstance添加synchronized,但实际上只有第一次执行getInstance方法,才需要真正的同步,当已经创建好对象时,后续无需在同步getInstance方法(导致后续每次调用getInstance,同步变成累赘,性能资源浪费)。

改进:使用双重检查加锁,减少使用同步。

添加volatile及synchronized同步块

public class GlobalNum {
     private static volatile GlobalNum globalNum;
     private int num=0;
     public static  GlobalNum getInstance()
     {
    	 if(globalNum==null){
             synchronized(GlobalNum.class){
                 if(globalNum==null)
                     globalNum = new GlobalNum();
             }
         }
         return globalNum;
     }
     public synchronized int getNum() //加锁
     {
    	 return ++num; //返回访问次数
     }
}

总结

  • 单例模式确保一个程序中的一个类只有一个实例。
  • 单例模式提供访问这个实例的全局访问点。
  • Java实现单例模式:私有构造器、一个静态变量、一个静态方法。
  • 确定性能资源的限制后,在多线程情况下,谨慎选择合适的方法实现单例模式。

参考:
HeadFirst设计模式、https://www.programcreek.com/2011/07/java-design-pattern-singleton/

你可能感兴趣的:(设计模式,单例模式,java,开发语言)