单例模式+计数器(synchronized的)。
    访问前，先判断有多少个线程在使用了。访问后，计数器减操作。

好像跟生产者消费者模式还不太一样。

引用 1 楼 dr_lou 的回复:

单例模式+计数器(synchronized的)。
  访问前，先判断有多少个线程在使用了。访问后，计数器减操作。

好像跟生产者消费者模式还不太一样。

对
隐藏构造函数，用类似于getInstance()方法得到引用，并计数，如果超出返回null

当前访问对象的线程数需要记录，超过n就阻塞，这个可以用ReentrantLock 
和dr_lou一样，这个计数器是要保证线程安全的，可以用AtomicInteger

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

引用 3 楼 dracularking 的回复:

当前访问对象的线程数需要记录，超过n就阻塞，这个可以用ReentrantLock 
和dr_lou一样，这个计数器是要保证线程安全的，可以用AtomicInteger

class X {
  private final ReentrantLock lock = new ReentrantLock();
  // ...

  public void m() {
  lock.lo……

需要恶补concurrent包了我

非常感谢楼上几位帮忙！

可是我是用GAE的，只能使用java最底层的那些API，比如wait和notify，其它的包用不了啊。

我想构造一个管理类，用对外提供begin和end函数，begin检查PersistenceManager对象是否可用，如果可用就返回该对象，如果不可用就等待。end函数释放PersistenceManager对象的使用权，并唤醒在begin中等待的线程。请问该如何设计？

忘了说了，就是想要处理PersistenceManager的并发访问。如果您能提供更好的办法请直说！

我还没有做到Think in Java，仍然Think Java in C++，思维混乱中。

public final class Test {

	private static PersistenceManagerFactory pmf = null;

	private static PersistenceManager pm = null;

	private static Properties properties = null;

	private static int instanceCount;

	static {

		properties.setProperty("...", "...");		

		pmf = JDOHelper.getPersistenceManagerFactory(properties);

		pm = pmf.getPersistenceManager();

	}

	

	private Test(){}

	

	public synchronized static PersistenceManager getPMInstance(){

		while (instanceCount != 0){

			Test.class.wait();

		}

		instanceCount = 1;

		return pm;		

	}

	

	public synchronized static void disposePMInstance(){

		pm.close();//??????useless? 

		pm = pmf.getPersistenceManager();

		instanceCount = 0;

		Test.class.notifyAll();

	}

}

可能有错误，特别是close那，只是粗略看了一下他的api
对工厂模式也不熟不知道getPersistenceManager();是不是同一个对象，如果不是应该可以

单例模式+计数器(synchronized的)。
  访问前，先判断有多少个线程在使用了。访问后，计数器减操作。

好像跟生产者消费者模式还不太一样。

这不就是POOL设计模式么？

看看这有什么问题

public class Test {

	private static PersistenceManager instance = new PersistenceManager();

    private static volatile int threadCounter = 0;

    // maximum concurrent threads allowed

    private static int N = 3;

	

	public static void rockNroll() {

		PersistenceManager instance;

		

		while(threadCounter >= N) {

			try {

				Thread.sleep(1000);

			} catch(InterruptedException e) {

				e.printStackTrace();

			}

		}

		

		if(threadCounter < N) {

			getAndAdd(1);

			System.out.println("current working threads is " + threadCounter);

			instance = doWork();

			getAndAdd(-1);

		} else {

			instance = null;

		}

		

		if(instance != null) {

			System.out.println("well done...");

		}

		

	}

	

	private static PersistenceManager doWork() {

		return getPMInstance();

	}

	

	private static synchronized void getAndAdd(int delta) {

		threadCounter += delta;

	}

	

    public static PersistenceManager getPMInstance() {

        return instance;		

	}

    

    public static void main(String[] args) {

		for(int i = 0; i < 100; i++) {

			new Thread() {

				public void run() {

					rockNroll();

				}

			}.start();

		}

	}



}



class PersistenceManager {

	

}

牛人咋这么多