package pers.niaonao.test;

import pers.niaonao.entity.GrilFriendUnSingleton;

/**
 * @author niaonao
 * 
 */
public class TestGrilFriend {

	public static void main(String[] args) {
		
		//对实体类创建两个对象
		GrilFriendUnSingleton n_first_grilfriend = new GrilFriendUnSingleton();
		GrilFriendUnSingleton n_next_grilfriend = new GrilFriendUnSingleton();
		
		String info = "n_first_grilfriend 和 n_next_grilfriend";
		
		//判断对象是否是同一个实例
		if (n_first_grilfriend != n_next_grilfriend) {
			info += "\n\t不是同一个实例，是两个不同的对象:"
					+ "\n\t魔法为我而存在，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t大小姐驾到，" + n_next_grilfriend.getGrilFriend();
		} else {
			info += "\n\t是同一个实例，同一个对象:"
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_next_grilfriend.getGrilFriend();
		}
		
		System.out.println(info);
	}
}

package pers.niaonao.entity;

/**
 * @author niaonao
 * 单例模式下的基本类
 */
public class GrilFriendBySingleton {

	//初始化静态私有变量grilfriend
	private static GrilFriendBySingleton grilfriend = null;
	
	/**
	 * 构造单例模式基本方法getInstance()
	 * 调用该方法，会先判断对象grilfriend是否不为null，即对象是否已存在，
	 * 若实例对象已存在则不再创建新对象，否则创建一个新对象给变量grilfriend。
	 * 
	 * 保证当前类只存在一个实体对象。即单例模式
	 * @return grilfriend
	 */
	public static GrilFriendBySingleton getInstance() {

		if (null == grilfriend)
			grilfriend = new GrilFriendBySingleton();

		return grilfriend;
	}
	
	//默认的构造方法
	public GrilFriendBySingleton() {
	}
	
	private String info = "我是你的新 GrilFriend";
	
	/**
	 * 获取对象信息的方法
	 * @return
	 */
	public String getGrilFriend() {
		return info;
	}
}

public class Singleton {
    private static Singleton uniqueInstance = null;
 
    private Singleton() {
       // Exists only to defeat instantiation.
    }
 
    public static Singleton getInstance() {
       if (uniqueInstance == null) {
           uniqueInstance = new Singleton();
       }
       return uniqueInstance;
    }
    // Other methods...
}

四、GrilFriend 在多线程下的线程安全

package pers.niaonao.test;

import pers.niaonao.entity.GrilFriendBySingleton;

/**
 * @author niaonao
 * 测试经典单例模式代码的线程安全问题
 * 
 */
public class TestGFriendSingle {  
    
    public static void main(String[] args) {   
          
    	Thread[] threads = new Thread[10];//模拟10 个线程
    	
        for(int i = 0 ; i < threads.length ; i++){  
        	threads[i] = new Thread() {
            	@Override
            	public void run() {
            		super.run();
            		//获取单例类的实例
            		System.out.print(GrilFriendBySingleton.getInstance().hashCode()+"\t");
            	}
            };  
        }  
          
        for (int j = 0; j < threads.length; j++) {  
        	threads[j].start();  //启动线程
        }  
    }  
}  

4-2 双锁机制下单例模式的线程安全

package pers.niaonao.entity;

/**
 * @author niaonao
 * 线程安全的单例模式
 * Double Check Locking 双锁机制，对单例进行两层加锁
 * 使用使用了volatile关键字来保证其线程间的可见性
 * 同步代码块中使用二次检查，以保证其不被重复实例化
 */
public class GFriendSingleMultithread {
    volatile private static GFriendSingleMultithread grilfriend = null;  
      
    //默认的构造方法通过private 修饰为私有方法，该单例类就只允许通过getInstance() 获取创建实例。
    private GFriendSingleMultithread(){
    	
    }  
       
    public static GFriendSingleMultithread getInstance() {  
        try {    
        	
            if(null == grilfriend){		//锁一：第一层检查
                Thread.sleep(300);  	//创建实例之前可能会有一些准备性的耗时工作 (参考其他博主的说法)
                
                //synchronized 修饰，同步代码块，处理多线程的关键字
                synchronized (GFriendSingleMultithread.class) {  
                	
                    if(null == grilfriend){//锁二：第二层检查
                    	grilfriend = new GFriendSingleMultithread();  
                    }  
                }  
            }   
        } catch (InterruptedException e) {   
            e.printStackTrace();  
        }  
        return grilfriend;  
    }  
}

package pers.niaonao.test;

import pers.niaonao.entity.GFriendSingleMultithread;

/**
 * @author niaonao
 * 测试双锁机制下的单例模式
 * 
 */
public class TestMultithread {  
    
    public static void main(String[] args) {
        
    	Thread[] threads = new Thread[10];//模拟10 个线程
        for(int i = 0 ; i < threads.length ; i++){  
        	threads[i] = new Thread() {
            	@Override
            	public void run() {
            		super.run();
            		//获取单例类的实例
            		System.out.print(GFriendSingleMultithread.getInstance().hashCode()+"\t");
            	}
            };  
        }  
          
        for (int j = 0; j < threads.length; j++) {  
        	threads[j].start();  //启动线程
        }  
    }  
}  

4-3 说明

4-4 标准线程安全的单例代码演示

public class Singleton {
	volatile private static Singleton uniqueInstance = null;

	private Singleton() {
		// Exists only to defeat instantiation.
	}

	public static Singleton getInstance() {

		try {

			if (uniqueInstance == null) {
				Thread.sleep(300);

				// synchronized 修饰，同步代码块，处理多线程的关键字
				synchronized (Singleton.class) {
					if (uniqueInstance == null) {
						uniqueInstance = new Singleton();
					}
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		return uniqueInstance;
	}
	// Other methods...
}