单例模式

1. 单例模式

以下是恶汉模式，类初始化的时候，就进行了new对象，如果没有调用getInstance方法，那么系统就提前消耗掉了内存

  public class  singleton {
       
     private static singleton  sing = new singleton();
      
     private singleton (){}
     
     public static singleton  getInstance (){
           return sing;
     }
 }

2. 以下为懒汉模式

   此时的懒汉模式，是线程不安全的，当多线程访问的时候，会同时new多个实例

1.package net.chopsuey.singleton;   
2.  
3.public final class LazySingleton   
4.{   
5.    private static LazySingleton singObj = null;   
6.  
7.    private LazySingleton()   
8.    {   
9.    }   
10.  
11.    public static LazySingleton getSingleInstance()   
12.    {   
13.        if (singObj == null)   
14.        {   
15.            singObj = new LazySingleton();   
16.        }   
17.        return singObj;   
18.    } 

为解决多线程问题，可以写一个内部类，当使用的时候才去实例化

一个静态内部类内的一个静态成员就可以保证它只在类被加载时只初始化一次。因此不管有多少个线程来调用它，都只能得到同个实例（类被加载时初始化的那个）。

  public class  singleton {
     static class  Userleton {
        static sinleton sing = new singleton();
             
      }    
      
      public singleton getInstance(){
         return Userleton.sing;
  }