Google 应用引擎标准 + Firebase 数据库

Question

我有一个 Google 应用引擎 + firebase 数据库后端架构。我正在编写一个 servlet，它应该从数据库中获取一些值，进行计算并使用这些值构建响应。问题是 onDataChange() 方法是异步调用的。一开始我会介绍我的代码，然后继续：

//Here I initialize a listener that would be called when the onDataChange() 
//method is finished to make the code synchronous.
    responseReadyListener = new ResponseReadyListener() {
            @Override
            public void onResponseReady() {
                responseReady[0] = true;
                synchronized (MyServlet.this) {
                    MyServlet.this.notify();
                }
            }
        };
        ref.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                    //notify the main thread that the response can be sent
                    responseReadyListener.onResponseReady();
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {

            }
        });
        //the loop that stops the main thread until onDataChange() finishes
        while (!responseReady[0]) {
            try {
                synchronized (this) {
                    if (!responseReady[0]) {
                       this.wait();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

现在的问题是，最近我读到只有一个 servlet 实例被创建来响应 http 请求。这就是为什么我不能使用 synchronized(this) 因为它会停止服务器获得的所有客户端响应的同步线程（我只需要停止 1 个主线程，只有一个请求的主线程）。如何正确摆脱方法异步？

Answer 1

我自己做了一些研究，发现了一个班级CountDownLatch。当您无法获得可运行的实例（不是您而是 api 创建线程时）时，像 ExecutorService 这样的其他类不适合，这正是我的情况。以下是其用法示例：

final CountDownLatch synchronizer = new CountDownLatch(N/*this number represents the nubmer of threads that should finish before continuation*/);

    ref.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
                //another thread, countDown() says CountDownLatch that 
                //one thread has finished its work (N = N - 1).
                synchronizer.countDown();
            }
        }
    });

    try {
        //main thread. Await() method stops the thread until countDown() is 
        //called N times, then execution continues.
        synchronizer.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}