写一个延迟加载的单例设计模式

单例模式的另外一种表现形式：懒汉式（延迟加载形式）

class Single

{

        private Single(){}

        private static Single s=null;

        public static Single getInstance()

        {

                if(s==null)

                        s=new Single();

                return s;

        }

}

类加载进来没有对象，只有调用了getInstance()方法时，才会创建对象

相对于饿汉式：类加载到内存，对象就已经存在了。

总结：实际开发中用的饿汉式比较多，懒汉式的问题在于多线程并发时保证不了唯一性。也就是说多线程运行时不安全。

class Single {
    private Single(){}
    private static Single s = null;
    public static Single getInstance(){
       if(s==null){
             synchronized(Single.class){

                       if(s==null){
                           s = new Single();
                        }
                     return s;
                }

        }
   }
}

class DLMODETest
{
public static void main(String[] args)
{
  new DLTest().show();
  
  System.out.println(Single2.getInstance());
}
}
class DLTest
{
static DLTest t = new DLTest();
public void show()
{
  System.out.println("单例设计模式测试！");
}
}

区别：
1，类加载时
饿汉式：直接在内存中建立对象.
懒汉式：只建立引用。并未创建对象。
2，多线程并发时：懒汉式会出现安全问题。
为了保证对象的唯一，需要加入一个关键字：synchronized，但是该关键字会降低效率.
所以建议使用饿汉式。
class Single1  //饿汉式单例
{
private static Single1 s = new Single1();
private Single1(){};
public static Single1 getInstance()
{
  return s;
}
}
class Single2  //懒汉式单例
{
private static Single2 s = null;
private Single2(){};
public static synchronized Single2 getInstance()
{
  if (s == null)
  {
   s = new Single2();
  }
  return s;
}
}

//懒汉式
class Single
{
        private  static SingleTon single=null;

        private SingleTon(){
        }

        public static Single getInstance(){                       
               
                synchronized(Single.class){

                        if(single==null){                                   //当多个线程操作时，第一个线程在判断single==null为true时，
                                single=new SingleTon();             //第一个线程切换到了临时堵塞状态，那么第二个线程在判断
                                                                                  //发现single==null还为true,这时就出问题了
                                                                               
                        }
                }

                return single;                                              //返回      
        }
}

/*
class Single
{
        private  static Single single=null;
       
        private Single(){
        }

        public synchronized static SingleTon getInstance(){               
       

                        if(single==null){                                 //当多个线程操作时，第一个线程在判断single==null为true时，
                                single=new Single();                   //第一个线程切换到了临时堵塞状态，那么第二个线程在判断
                                                                                  //发现single==null还为true,这时就出问题了
                                                                               
                        }
               

                return single;
        }
}*/

package com.itheima;

public class Test6 {
        /*
         *6、 编写一个延迟加载的单例设计模式。
         */

        private int num;

        public void setNum(int num) {
                this.num = num;
        }

        public int getNum() {
                return num;
        }

        private Test6() {
        }
        //懒汉式
        private static Test6 s = null;
       

        public static synchronized Test6 getSingle() {
                if (s == null) {
                        s = new Test6();
                }
                return s;
        }

        public static void main(String[] args) {
                Test6 s1 = Test6.getSingle();
                Test6 s2 = Test6.getSingle();
                s1.setNum(22);
                System.out.println(s2.getNum());       
}

       

        }

public class Single {

        /**
         * 加了synchronized关键字后的懒汉式单例模式
         */
        private static Single s = null;
        private Single(){};
        public static synchronized Single getInstance()
        {
          if (s == null)
          {
           s = new Single();
          }
          return s;
        }


}

上一个运行慢，这个还好。

public class Single {

        /**
         * 加了synchronized关键字后的懒汉式单例模式
         */
        private static Single s = null;
        private Single(){};
        public static Single getInstance()
        {
          if (s == null)
          {
                  synchronized(Single.class)
                  {
                          if (s == null)
                          {
                                  s = new Single();
                          }
                  }
          }
          return s;
        }


}