Concurrency,Java 并发

//TestLock.java
package com.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestLock {

	private static int cnt=0;
	private final int num=cnt++;
	private static Lock lock=new ReentrantLock();
	
	private TestLock(){}
	private static TestLock ins=null;
	public static /*synchronized */ TestLock getInstance(){		
		if(ins==null){
			//若在此处声明锁，则不能保证多个线程访问时，此段代码的安全
			//Lock lock=new ReentrantLock();
			lock.lock();
			try {
				if (ins== null) {
					TimeUnit.MILLISECONDS.sleep(10);
					ins = new TestLock();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			finally{
				lock.unlock();
			}
		}
		return ins;
	}
	
	public int getNum() {
		return num;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ExecutorService svs = Executors.newCachedThreadPool();
		List< Future<TestLock> > lstObjs=new ArrayList< Future<TestLock> >();
		for (int i = 0;i<10;i++){
			 lstObjs.add( svs.submit(new TestLockThread()) );
		}
		for (Future<TestLock> ftl : lstObjs) {
			try {
				TestLock tl=  ftl.get();
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		svs.shutdown();
	}

}

//TestLockThread.java

package com.test.thread;
import java.util.concurrent.Callable;

public class TestLockThread implements Callable<TestLock> {
	@Override
	public TestLock call() throws Exception {
		TestLock tl = TestLock.getInstance();
		System.out.println("call:"+tl.getNum());
		return tl;
	}

}