多线程验证 懒汉式单例模式可能会出现不单例的情况

package ThreadDemo;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

//懒汉式单例，线程不安全的,使用同步机制

//对于一般的方法内，使用同步代码块，可以考虑使用this
//对于静态方法而言，使用当前类本身充当锁

/*JAVA类首次装入时，会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的，
 *  静态成员变量和静态初始化块级别相同，非静态成员变量和非静态初始化块级别相同。

 先初始化父类的静态代码--->初始化子类的静态代码-->
 初始化父类的非静态代码--->初始化父类构造函数--->
 初始化子类非静态代码--->初始化子类构造函数
 */

public class TestSingleton {
	public static void main(String[] args) throws Exception {
		
		List<Singleton> singletonlist= new ArrayList<Singleton>();
		Set<Singleton> singletonSet= new HashSet<Singleton>();
		
		List<Callable> callableList= new ArrayList<Callable>();
		List<Future> futureList= new ArrayList<Future>();
		// 获取多线程的返回值
		// 1创建一个线程池
		ExecutorService pool = Executors.newFixedThreadPool(1000);
		
		for(int i=0;i<1000;i++){
			//2创建有返回值的任务线程
			Callable c1 = new ThreadTestSingle();
			// 3执行任务并获取Future对象
			Future f1 = pool.submit(c1);
			//4从Future对象上获取任务的返回值
			singletonlist.add((Singleton) f1.get());
			singletonSet.add((Singleton) f1.get());
		}
		System.out.println(singletonlist.size());
		System.out.println(singletonlist.get(0)==singletonlist.get(1));
		System.out.println(singletonSet.size());

		// 5关闭线程池
		pool.shutdown();
	}
}

class Singleton {
	private Singleton() {
	}

	private static Singleton instance = null;

	public static Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

/* 有返回值的多线程 */
class ThreadTestSingle implements Callable {

	@Override
	public Singleton call() throws Exception {
		// TODO Auto-generated method stub
		return Singleton.getInstance();
	}

}

执行结果是：

1000

true

1

 

本来想循环创建多线程，但是因为for循环是先后的，所有，其实只是第一个循环去创建的，就当学习下有返回值的多线程吧。。。 如何用for循环去验证？应该不好使吧。。

 

 倒是下面的 这种，基本都能测试出来，不是相同对象

package ThreadDemo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

//懒汉式单例，线程不安全的,使用同步机制

//对于一般的方法内，使用同步代码块，可以考虑使用this
//对于静态方法而言，使用当前类本身充当锁

/*JAVA类首次装入时，会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的，
 *  静态成员变量和静态初始化块级别相同，非静态成员变量和非静态初始化块级别相同。

先初始化父类的静态代码--->初始化子类的静态代码-->
初始化父类的非静态代码--->初始化父类构造函数--->
初始化子类非静态代码--->初始化子类构造函数
*/


public class TestSingleton2 {	
	public static void main(String[] args) throws Exception {
		//获取多线程的返回值
		 //1创建一个线程池 
        ExecutorService pool = Executors.newFixedThreadPool(2); 
        //2创建两个有返回值的任务 
        Callable c1 = new ThreadTestSingle(); 
        Callable c2 = new ThreadTestSingle(); 
        //3执行任务并获取Future对象 
        Future f1 = pool.submit(c1); 
        Future f2 = pool.submit(c2); 
        //4从Future对象上获取任务的返回值，并输出到控制台 
        Singleton singleton1=(Singleton) f1.get();
        Singleton singleton21=(Singleton) f2.get();
        System.out.println();
        
 
		System.out.println(singleton1==singleton21);
		//5关闭线程池 
        pool.shutdown(); 
	}
}

class Singleton{
	private Singleton(){}
	private static Singleton instance=null;
	public static Singleton getInstance(){
		
/*				if (instance == null) {
					synchronized (Singleton.class) {
						if(instance==null)
						instance = new Singleton();
					}
				}*/
		
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}
}

/*有返回值的多线程*/
class ThreadTestSingle implements Callable{

	public Singleton call() throws Exception {
		// TODO Auto-generated method stub
		return Singleton.getInstance();
	}
	
}

 

打印结果大多数都是false