首页 >  JAVA频道 > 实训项目 > 

多线程单实例

多线程单实例

作者:yjl 来源:华育国际 时间:2015-02-27 访问次数:1915
只要多线程能成功获取单例(即多线程获得的单例实例是相同的),必然能共享单例的状态 * 注意: * 1、单实例,被一个线程调用时,另一个线程也可以同时调用

/**
 * 只要多线程能成功获取单例(即多线程获得的单例实例是相同的),必然能共享单例的状态
 * 注意:
 * 1、单实例,被一个线程调用时,另一个线程也可以同时调用
 * 2、但同一个时刻,单实例的某个成员方法(成员变量?)可以被多个线程访问??实验结果好像是的(反例很少,担心是程序问题)
 * 3、某个时刻,某个线程调用单实例的某个成员方法A访问资源r,那么同时,另一个线程B可以调用单实例的其它成员方法B访问资源r??个人觉得应该是的,但实验结果好像不是的
 *
 * 单实例,最好不要有成员变量,都改为局部变量(方法中的参数、声明)。
 * 局部变量是线程安全的。
 * 如果一定需要成员变量,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();
    
    }
}