黑马程序员技术交流社区

标题: 编写 一个延迟加载单例设计模式 [打印本页]
作者: ZZGFF    时间: 2015-2-21 00:45
标题: 编写 一个延迟加载单例设计模式
注释代码，谢谢啊。求教
作者: a986875894    时间: 2015-2-21 06:56
  1. class SingleDemo{
  2.         private static SingleDemo sd = null;
  3.         private SingleDemo(){};
  4.         private Object obj = new Object();
  5.         public static SingleDemo getSingleDemoObject()
  6.         {
  7.              synchronized(obj)
  8.             {
  9.                 if(sd==null)
  10.                 {
  11.                   sd = new SingleDemo();
  12.                   return sd;
  13.                 }
  14.                 else
  15.                 {
  16.                   thorws new RuntimeException("获取失败");
  17.                 }
  18.             }
  19.         }
  20.         public void Test()
  21.         {
  22.                 System.out.println("Test");
  23.         }
  24. }
  25. class Single
  26. {
  27.         public static void main(String[] args){
  28.                 SingleDemo sd = SingleDemo.getSingleDemoObject();
  29.                 sd.Test();
  30.         }
  31. }
复制代码
作者: a986875894    时间: 2015-2-21 06:57
记事本敲的 不保证没有错误！
作者: sofeel    时间: 2015-2-21 15:57
即实现，单例模式中的懒汉模式。先给出代码：

public class Lazy {
        private Lazy lazy;
        private Lazy(){       
        }
       
        public Lazy getInstance(){
                if(lazy==null)
                {
                        synchronized (this) {
                                if(lazy==null)
                                        lazy=new Lazy();
                        }
                }
                return lazy;
        }
}
思路：
一，单例设计；
二，解决线程安全问题。

步骤：
一、实现单例三步：
1，私有本类对象属性：private Lazy lazy;
2，私有构造方法：private Lazy(){ }
3,对外暴漏获取实例的功有方法
public Lazy getInstance(){
       if(lazy==null)
             lazy=new Lazy();
       return lazy;       
}
这样基本功能已经完成，若是单线程程序，就ok了。可如果是多线程程序，还有线程安全问题。
二、解决线程安全问题
java中提供了解决线程安全的机制，即同步机制。
实现同步的关键字synchronized ，被该关键字修饰的内容相当于被锁住了，钥匙由当前的使用者保管。
实现同步有两种方式：同步函数、同步代码块。
同步函数，即锁住函数的代码块。
public synchronized Lazy getInstance(){...}

同步代码块，即选择性的锁住相关语句。
synchronized (this) {
        if(lazy==null)
                lazy=new Lazy();
}
同步函数，每次都要判断锁，影响效率。这里选择同步代码块，更为合理。
要体现出同步代码块的这一优势，写成上面的样子，无异于同步函数。所以代码需要进一步优化，用双重判断，减少对锁的判断。

               if(lazy==null)
                {
                        synchronized (this) {
                                if(lazy==null)
                                        lazy=new Lazy();
                        }
                }












欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2