多线程单实例

/**
 * 只要多线程能成功获取单例(即多线程获得的单例实例是相同的),必然能共享单例的状态
 * 注意：
 * 1、单实例，被一个线程调用时，另一个线程也可以同时调用
 * 2、但同一个时刻，单实例的某个成员方法（成员变量）可以被多个线程同时访问。
 * 
 * 单实例，最好不要有成员变量，都改为局部变量（方法中的参数、声明）。
 * 局部变量是线程安全的。
 * 如果一定需要成员变量，http://blog.csdn.net/shiyanming1223/article/details/6933420
 * 
 * 同步属性方法解决属性读写，会增加时间开销（同一时刻只用一个线程可以访问该属性方法）
 * 
 * 
 * 下面的程序是验证用的，实际中千万别用。
 * 【最佳单实例生成方式： 
	 *  public class Singleton{        
		    private Singleton(){        
		        …        
		    }        
		    private static class SingletonContainer{        
		        private static Singleton instance = new Singleton();        
		    }        
		    public static Singleton getInstance(){        
		        return SingletonContainer.instance;        
		    }        
		} 
	】
 */
package t;
import java.util.*;
import java.lang.Thread;

//单实例--非惰性加载方法一， 这样的代码缺点是：第一次加载类的时候会连带着创建Singleton实例，这样的结果与我们所期望的不同，因为创建实例的时候可能并不是我们需要这个实例的时候。同时如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，那么创建Singleton消耗的系统资源就被白白浪费了。
class Singleton {
    
    //私有，静态的类自身实例
    private static Singleton instance = new Singleton();//这种非惰性方法，不会有线程安全问题（不会生成多个实例对象）。若是这里赋予NULL，而在getInstance()中判断是否为空，再调用构造函数初始化，会有线程安全问题。
    
    public int r = 0;//资源
     
    //私有的构造子(构造器,构造函数,构造方法)
    private Singleton(){}
     
    //公开，静态的工厂方法
    public static Singleton getInstance() {
        return instance;
    }
    //某个单实例方法，某个时刻只能被一个线程访问？？--应该不是的
    public void prints(){//prints()被一个线程执行的过程中，还会被另一个线程执行吗---如果不会，则r+1000递增---结果有时会，为什么
    	int j=0;//若还会被另一个线程执行，那另一个线程中这个j是从0开始吗？是的。因为j是局部变量，线程安全。
    	while(j++<2000)r++;
    	System.out.println("r = "+r);
    }
    public void prints2(){
    	System.out.println("r2 = "+r);//prints()访问r的同时，prints2()不会访问，为什么---应该会的
    }
}

class Th extends Thread{
	
	Singleton obj = Singleton.getInstance();
	public Th(int v){	
		obj.r = v;//共享单实例的资源
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		/*int x = 0;
		while(x++<100){
			print();
		}*/
		while(obj.r<100000){
			
			/*try {
				sleep(10);//这里被另一个线程执行ThT obj.prints2()，但未来得及obj.r++;就继续执行该线程Th的obj.prints();则会输出相同值----结果中有相同值
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			obj.prints();
			/*try {
				sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			//obj.r++;
		}
		
		super.run();
	}

}
class ThT extends Thread{
	
	Singleton obj = Singleton.getInstance();
	public ThT(int v){	
		obj.r = v;//共享单实例的资源
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		/*int x = 0;
		while(x++<100){
			print();
		}*/
		while(obj.r<100000){
			/*try {
				sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			obj.prints();
			/*try {
				sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			//obj.r++;
		}
		
		super.run();
	}

}

class ThTT extends Thread{
	
	Singleton obj = Singleton.getInstance();
	public ThTT(int v){	
		obj.r = v;//共享单实例的资源
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		/*int x = 0;
		while(x++<100){
			print();
		}*/
		while(obj.r<100000){
			/*try {
				sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			obj.prints2();//会出现51 52 吗？？
			/*try {
				sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			//obj.r++;
		}
		
		super.run();
	}

}

public class Test7_3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThTT th3 = new ThTT(10);
		Th th1 = new Th(-1000);//改变资源
		ThT th2 = new ThT(-2000);//改变资源---因为是单实例，因此th1的资源也被改变
		th1.start();//
		th2.start();
		th3.start();

	}
}