[设计模式]单例模式(考虑多线程)

下面这个程序比较经典,现在忘了. 先保存下来.

import java.util.ArrayList;

public final class SingletonObject {
    private static SingletonObject obj;
    private SingletonObject(){}
    //如果在方法上声明同步，会成为系统并发访问的瓶颈
    public static SingletonObject getInst(){
        if(obj == null){
            synchronized("aa"){
                if(obj == null){
                    obj = new SingletonObject();
                }
            }
        }
        return obj;
    }

    //1.将对象声明到类中作为类变量，初始化
    //违反了第一条
    //2.1.将对象声明到类中作为类变量，且不初始化
    //在static中初始化
    //总要有一个初始化的代码，写到哪里？如果写到static代码块中，那么类加载时，就会被执行，和直接写obj2 = ....一样的
    //上述方案违反了下面的第一条
    //2.2.将对象声明到类中作为类变量，且不初始化
    //将初始化写入到获取对象的方法中
    //obj2 = new SingletonObject();
    //上述方案违反了下面的第二条
    //2.2.1.将对象声明到类中作为类变量，且不初始化
    //在获取方法中进行null的判定，进行初始化
    //上述方案违反了下面的第三条
    //最终方案：既要进行对象的一次初始化，又不能将该初始化语句放入到获取方法中
    //Java中哪种方案是归属于类的模型体系下的且只执行一次，且在类加载时不进行加载，但是使用时才进行加载，那么这个方案就是最终方案
    //内部类解决方案
    
    private static class Inner{
        //将对象初始化的操作加入到内部类中
        private static final SingletonObject obj2 = new SingletonObject();
    }
    
    public static SingletonObject getInst2(){
        //既需要延迟加载，不使用不创建
        //又要保障创建的时候不会被多次创建，做成单例
        //又要求每次获取的时候最好不做null判定
        return Inner.obj2;
    }
    
    public static void main2(String[] args) {
        System.out.println(SingletonObject.getInst());
        System.out.println(SingletonObject.getInst());
        System.out.println(SingletonObject.getInst());
    }
    
    public static void main(String[] args) {
        
        long t1 = System.currentTimeMillis();
        long start = 90000000000000001L;
        long end = 90000000000000100L;
        long refMax = (long)Math.sqrt(end);
        ArrayList<Long> primes = new ArrayList<Long>();
        OUT:
        for(long i = 2;i <= refMax ; i++){
            for(long j = 2;j<= Math.sqrt(i);j++){
                if(i % j == 0){
                    continue OUT;
                }
            }
            primes.add(i);
        }
        System.out.println("end");
        OUT:
        for(long i = start;i<=end;i++){
            for(Long prime:primes){
                if(i % prime == 0){
                    continue OUT;
                }
            }
            System.out.print(i+"	");
        }
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
        
        
        OUT:
        for(int i = 101;i <= 200 ; i++){
            for(int j = 2;j<= Math.sqrt(i);j++){
                if(i % j == 0){
                    continue OUT;
                }
            }
            System.out.print(i+"	");
        }
    }
}
/*
A走到这里，时间片到期，该B运行
B执行完毕了，此时obj对象是B线程new出来的
此时B执行完毕，A又运行，由于是从此处时间片到期，恢复运行后，还从当前行继续
执行下面的代码，A线程又创建了一个对象
此时B创建了一次，A创建了一次，外面最少是两个对象
*/