//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;
  }

}