谁能说一下他们的优缺点，求详细

/**
* 单利设计模式
*
*
* 饿汉式
*
* class Single{
*
*                 private static final Stingle s = new Single();
*                 private Single(){}
*                 public static Single getInstance(){
*
*                                 return s;
*
*                 }
*
* }
*
*/

package com.hm.thread;

public class SingleDemo {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub

        }

}

//懒汉式
/*懒汉式的特点是延迟对象的加载，懒汉式延迟加载有没有问题？
*
* 有
*
* 如果多线程访问是会出现安全问题
*
* 怎么解决？
*
* 可以加同步来解决。而加同步的方式：用同步代码块和同步函数都可以，但是都会有些低效，用双重判断的方法能解决这个低效问题。
* 同步锁是给类所属的字节码文件
*
*
* */

class Single{
       
       
        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;
        }
       
       
}

这个毕老师视频里有详解，不如自己去看看，更容易理解。

/*
这个是先初始化对象。
称为：饿汉式。

Single类一进内存，就已经创建好了对象。
class Single
{
        private static Single s = new Single();
        private Single(){}
        public static Single getInstance()
        {
                return s;
        }
}
*/

//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single
{
        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;
        }
}

class  
{
        public static void main(String[] args)
        {
                System.out.println("Hello World!");
        }
}
懒汉式存在安全隐患，需要使用同步来解决，效率不够高。
定义单例，建议使用饿汉式。

饿汉式:
  public class Singleton{
  private static Singleton singleton = new Singleton ();
  private Singleton (){}
  public Singleton getInstance(){return singletion;}
  }  

  懒汉式:
  public class Singleton{
  private static Singleton singleton = null;
  public static synchronized synchronized getInstance(){
  if(singleton==null){
  singleton = new Singleton();
  }
  return singleton;
  }
  }  

  比较:
  饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
  懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
建议使用第一种  

/*
饿汉式   特点： 类进内存就创建好了对象

class Single
{
        private static final Single s=new Single();
        private Sinlge(){}
        public static void getinstance()
        {
        return s;
        }
}


*/


懒汉式 特点：使用对象才初始化， 叫做对象的延迟加载
class Single
{
        private static Single s=null;
        private Single(){}
        public static void getInstance()
        {
                if(s==null)
                        synchronized(Single.class)//锁：该类所属的字节码文件
                        {
                                if(s==null)
                                        {
                                                Single s=new Single

();
                                        }
                               
                        }
                return s;
        }
}
懒汉式存在安全隐患，需要同步来解决，效率变低。
所以定义单例，一般使用饿汉式。

但懒汉式 有几个考点要牢记：
1.同步的使用
2.双重判断减少锁的使用可以提高效率
3.同步时使用的锁为：该类所属的字节码文件