程序员一代码搬运工
【Java学习心得和Java学习技术个人总结】

java单例模式(具体代码显现)两种方法

判断是否存在

/** 
 * 懒汉式 
 */
public class LazySingleInstance {  
    
    // 私有构造方法  
    private LazySingleInstance(){};  
        
    // 私有的类对象  
    private static LazySingleInstance instance = null;  
        
    // 缺点:  
    // 1 每次都需要去判断instance 是否为空  
    // 2 调用时才去new对象,响应比较慢  
    // 3 多线程时,线程不安全,多线程同时获取该对象,线程不安全,可能会产生多个对象出来  
    public static LazySingleInstance getInstance() throws InterruptedException {  
        // 每次都需要判断instance是否为空,浪费资源  
        if (null == instance) {  
            Thread.sleep(1000);  
            instance = new LazySingleInstance();  
        }  
            
        return instance;  
    }  
}

考虑线程

/**
 * 懒汉式线程安全方法一
 */ 

public class ThreadSafeSingleInstance {  
   
    // 私有的静态实例  
    private static ThreadSafeSingleInstance instance;  
       
    // 私有的构造方法  
    private ThreadSafeSingleInstance(){};  
       
    /** 
     * 懒汉式线程安全方法 
     * 同步锁保护 
     * 缺点: 
     * 性能低下,且同时每次均需检查实例是否存在 
     * @return 
     * @throws InterruptedException  
     */ 
    public synchronized static ThreadSafeSingleInstance getInstance() throws InterruptedException {  
        if (instance == null) {  
            Thread.sleep(1000);  
            instance = new ThreadSafeSingleInstance();  
        }  
           
        return instance;  
    }  
       
}
/** 
 * 懒汉式线程安全方法二 
 */ 
public class ThreadSafeSingleInstance {  
   
    // 私有的静态实例  
    private static ThreadSafeSingleInstance instance;  
       
    // 私有的构造方法  
    private ThreadSafeSingleInstance(){};  
       
    /** 
     * 同步块保护加二次判断 
     * 解决问题 
     */ 
    public static ThreadSafeSingleInstance getInstance() throws InterruptedException {  
        if (instance == null) {  
            // 进方法后进行实例判断,若实例为空,进入同步块  
            // 多线程时,多个线程会同时进入到同步块外面等待  
            // 此时,一个线程拿到ThreadSafeSingleInstance.class 后,其他线程在synchronized块外面等待  
            // 待锁释放时,一个等待的线程拿到锁,同时再次检查实例是否为空  
            // 并决定是否要创建实例  
            synchronized (String.class) {//ThreadSafeSingleInstance.class) {  
                Thread.sleep(1000);  
                if (instance == null) {  
                    instance = new ThreadSafeSingleInstance();  
                }  
            }  
        }  
           
        return instance;  
    }  
       
}

 

每次都去new

 

/** 
 * 饿汉式 
 */ 
public class HungrySingleInstance {  
   
    // 私有的构造方法  
    private HungrySingleInstance(){};  
       
    // 静态类变量,初始化类时变创建对象  
    private static HungrySingleInstance instance = new HungrySingleInstance();  
       
    // 或采用静态块形式初始化instance  
    static {  
        instance = new HungrySingleInstance();  
    }  
       
    /** 
     * 获取实例方法 
     * 优点: 
     * 线程安全,且不存在懒汉式的二次判断问题 
     * 缺点: 
     * 初始化即new 实例对象出来,违背资源利用习惯(即不管用不用都初始化实例出来) 
     * @return 
     */ 
    public static HungrySingleInstance getInstance() {  
        return instance;  
    }  
}

 

 

测试类

 

public class SingleInstanceTest implements Runnable{  
   
    HungrySingleInstance hungrySingleInstance = null;  
       
    LazySingleInstance lazySingleInstance = null;  
       
    ThreadSafeSingleInstance threadSafeSingleInstance = null;  
       
//  @Override  
//  public void run() {  
//      hungrySingleInstance = HungrySingleInstance.getInstance();  
//      System.out.println("hungrySingleInstance.hashCode() " + hungrySingleInstance.hashCode());  
//        
//  }  
       
//  @Override  
//  public void run() {  
//      try {  
//          lazySingleInstance = LazySingleInstance.getInstance();  
//      } catch (InterruptedException e) {  
//          e.printStackTrace();  
//      }  
//      System.out.println("lazySingleInstance.hashCode() " + lazySingleInstance.hashCode());  
//  }  
       
    @Override  
    public void run() {  
        try {  
            threadSafeSingleInstance = ThreadSafeSingleInstance.getInstance();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("threadSafeSingleInstance() " + threadSafeSingleInstance.hashCode());  
    }  
   
    public static void main(String args[]) throws InterruptedException{  
        SingleInstanceTest singleInstanceTest = new SingleInstanceTest();  
           
        for (int i=0; i< 100; i++) {  
            Thread t = new Thread(singleInstanceTest, String.valueOf(i));  
            t.start();  
        }  
    }  
}

 

赞(0)
未经允许不得转载:程序员一代码搬运工 » java单例模式(具体代码显现)两种方法
分享到: 更多 (0)