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;

	}



}