1. 例：（饿汉式）
   
2. 1.        class Student{
   
3. 2.                private static Student s=new Student();//创建本类对象
   
4. 3.                private Student(){}                          //将构造函数私有化，保证对象的唯一性
   
5. 4.                public static Student getStudent(){        //定义一个方法，可获得该对象
   
6. return s;
   
7. 5.                }
   
8. 6.        }
   
9. 例：（赖汉式）
   
10. 7.        class Student{
    
11. 8.                private static Student s=null;
    
12. 9.                private Student(){}                          //将构造函数私有化，保证对象的唯一性
    
13. 10.                public static Student getStudent(){        //定义一个方法，可获得该对象
    
14.                       if(s==null)
    
15.                       s=new Student();                //该方法被调用时，建立唯一对象
    
16.                       return s;
    
17. 11.                }
    
18. 12.        }
    

复制代码

如果对某个业务类Service 采用了单例模式(饿汉式),那么其他类通过getInstance()获得的实例去访问该service 的方法,是否存在线程安全问题?代码如下
public class UrlService {


      private static UrlService instance = new UrlService();

private UrlService() {
}

public static UrlService getInstance() {
return instance;
}

public void addUrl(HttpServletRequest request) {
                Stack<String> urlStack = (Stack<String>) request.getSession().getAttribute("stack");

urlStack.push(url);
                request.getSession().setAttribute("stack", urlStack);
}


public String getUrl(HttpServletRequest request) {
Stack<String> urlStack = (Stack<String>) request.getSession().getAttribute("url");
String url = urlStack.pop();
request.getSession().setAttribute("stack", urlStack);
return url;
}

}
  多个线程访问addUrl和getUrl时是否是线程安全的?

懒汉和饿汉虽然都是单例设计模式，饿汉是事先实例化，创建对象时才调用它，占用一定的内存资源，但是懒汉是预先判断是否存在实例化的对象，如果有拿来用，没有就临时创建对象，降低内存占用率，优化内存。

麻烦帮我写一下赖汉式，双重判断要解决同步问题的代码，这个同步问题怎么产生的？

饿汉式只要程序运行就会New一个对象，不会判断该对象是否存在，而是直接生产一个对象。
懒汉式是根据需要来创建对象，程序运行后先判断对象是否存在，如果不存在才New一个对象，保证了安全性，避免了内存空间的浪费
另外，懒汉式需要解决同步问题，通过双重判断和同步代码块解决。
通过双重判断使其效率大大提高，减少判断次数

1. class Single{
   
2.         private static Single s=null;
   
3.         private Single() {}
   
4.         public static Single getInstance(){
   
5.                 if(s==null)
   
6.                 {
   
7.                         synchronized (Single.class) {
   
8.                         if(s==null)
   
9.                         //-->A 首先A进来
   
10.                         //-->B B进来 两个都进来就New了多个对象
    
11.                         //为了保证内存唯一性，不允许一个类存在多个对象
    
12.                         s=new Single();
    
13.                 }
    
14.                 }       
    
15.         return s;
    
16.         }
    
17.        
    
18. }

复制代码

懒汉式是，只有用到这个用例的时候，再将他实例化，不会浪费，所以效率要高一些。
饿汉式则是程序只要开始，就将他实例化，到用到他的时候就省去了再实例的时间，所以速度和反应快。这是这俩的区别
不过差距不会那么明显。
但是大项目，在效率上体现的就有点明显了。