完美解决单例设计模式中懒汉式线程安全的问题

首先写个单例：

public class singledemo { 
  private static singledemo s = null; 
  private singledemo(){} 
  public static singledemo getinstance(){ 
    if(s == null){ 
      s = new singledemo(); 
    } 
    return s; 
  } 
} 

写个测试类：

public class threaddemo3 { 
   
  public static void main(string[] args) { 
    singledemo s1 = singledemo.getinstance(); 
    singledemo s2 = singledemo.getinstance(); 
    system.out.println(s2 == s2); 
  } 
} 

运行结果一直都是true,说明单线程下是没问题的，下面写个多线程来访问单例

public class threadtest implements runnable { 
  //存放单例对象，使用set是为了不存放重复元素 
  public set<singledemo> singles = new hashset<singledemo>(); 
  @override 
  public void run() { 
    //获取单例 
    singledemo s = singledemo.getinstance(); 
    //添加单例 
    singles.add(s); 
  } 
} 

使用多线程并发访问单例：

public class threaddemo3 { 
   
  public static void main(string[] args) { 
//   singledemo s1 = singledemo.getinstance(); 
//   singledemo s2 = singledemo.getinstance(); 
//   system.out.println(s2 == s2); 
    threadtest t = new threadtest(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    new thread(t).start(); 
    system.out.println(t.singles); 
  } 
} 

运行结果如下：
[com.persagy.thread.singledemo@1bc4459, com.persagy.thread.singledemo@150bd4d]

或

[com.persagy.thread.singledemo@12b6651]

说明有线程并发访问安全问题，获取的不一定都是同一个实例

如何解决线程安全问题呢？

当然使用同步锁机制了啊

下面改进单例：

public class singledemo {
	private static singledemo s = null;
	private singledemo(){}
	public static synchronized singledemo getinstance(){
		if(s == null){
			s = new singledemo();
		}
		return s;
	}
}

加入同步函数后线程安全问题解决了

运行多次都是获取同一个实例，不会出现2个实例的情况了

[com.persagy.thread.singledemo@12b6651]

但是在多线程并发访问的情况下，每个线程每次获取实例都要判断下锁，效率比较低，为了提高效率，我加入了双重判断的方法，解决了效率的问题

代码如下：

public class singledemo {
	private static singledemo s = null;
	private singledemo(){}
	public static singledemo getinstance(){
		/*如果第一个线程获取到了单例的实例对象，
		 * 后面的线程再获取实例的时候不需要进入同步代码块中了*/
		if(s == null){
			//同步代码块用的锁是单例的字节码文件对象，且只能用这个锁
			synchronized(singledemo.class){
				if(s == null){
					s = new singledemo();
				}
			}
		}
		return s;
	}
}

用这种方式解决了懒汉式的线程安全问题，也提高了效率，但是在实际开发中还是用饿汉式的比较多，毕竟这个代码比较多，比较繁琐。

以上就是小编为大家带来的完美解决单例设计模式中懒汉式线程安全的问题全部内容了，希望大家多多支持~