Google app engine 如果应用程序在Google App Engine上调用10个以上的异步URL获取，会发生什么情况？

在异步URL获取上读取Google应用程序引擎：

该应用程序最多可以同时拥有10个用户 异步URL获取调用

如果应用程序一次调用10个以上的异步获取，会发生什么情况？

---

谷歌应用程序引擎是否会引发异常，或者只是将等待服务的剩余呼叫排队

500个错误开始发生。默默地

您只有在查看所有请求下的日志时才能发现这些问题（不要列为错误）。它只是说“请求被中止，因为您达到了同时请求的限制”

---

因此，当您进行大量异步调用时，请确保能够处理其中一些突然中断的调用。

嗯，Swizzec是不正确的。易于测试：

rpc = []
for i in range(1,20):
    rpc.append(urlfetch.createrpc())
    urlfetch.make_fetch_call(rpc[-1],"http://stackoverflow.com/questions/3639855/what-happens-if-i-call-more-than-10-asynchronous-url-fetch")

for r in rpc:
    response = r.get_result().status_code

这不会返回任何异常。事实上，这很好用！请注意，对于不计费的应用程序，您的结果可能会有所不同

Swizec报告的是一个不同的问题，与应用程序的最大同时连接有关。对于付费应用程序，这里没有实际限制，顺便说一句，它只是向外扩展（根据1000ms规则）

---

GAE无法知道您的请求处理程序将发出阻止URL获取，因此他看到的连接500与他的应用程序实际执行的操作无关（顺便说一句，如果您的平均请求响应时间>1000毫秒，则您可能会增加500）。

看看这是否回答了您的问题：

---

这是一个老问题，但我认为公认的答案不正确或过时，可能会让人困惑。事实上，我已经测试了几个月了，但根据我的经验，Swizec非常正确，GAE不会排队，而是会使大多数异步URL获取失败，超过了每个请求大约10个同步URL的限制

有关限制的说明，请参见和

David Underhill提出了一种新的方法，它对超过应用程序代码限制的异步URL获取进行排队

我为Java实现了类似的功能，它同步阻止（由于缺少回调函数或ListenableFutures）额外的请求：

/**
 * A URLFetchService wrapper that ensures that only 10 simultaneous asynchronous fetch requests are scheduled. If the
 * limit is reached, the fetchAsync operations will block until another request completes.
 */
public class BlockingURLFetchService implements URLFetchService {
    private final static int MAX_SIMULTANEOUS_ASYNC_REQUESTS = 10;

    private final URLFetchService urlFetchService = URLFetchServiceFactory.getURLFetchService();
    private final Queue<Future<HTTPResponse>> activeFetches = new LinkedList<>();

    @Override
    public HTTPResponse fetch(URL url) throws IOException {
        return urlFetchService.fetch(url);
    }

    @Override
    public HTTPResponse fetch(HTTPRequest request) throws IOException {
        return urlFetchService.fetch(request);
    }

    @Override
    public Future<HTTPResponse> fetchAsync(URL url) {
        block();

        Future<HTTPResponse> future = urlFetchService.fetchAsync(url);
        activeFetches.add(future);
        return future;
    }

    @Override
    public Future<HTTPResponse> fetchAsync(HTTPRequest request) {
        block();

        Future<HTTPResponse> future = urlFetchService.fetchAsync(request);
        activeFetches.add(future);
        return future;
    }

    private void block() {
        while (activeFetches.size() >= MAX_SIMULTANEOUS_ASYNC_REQUESTS) {
            // Max. simultaneous async requests reached; wait for one to complete
            Iterator<Future<HTTPResponse>> it = activeFetches.iterator();
            while (it.hasNext()) {
                if (it.next().isDone()) {
                    it.remove();
                    break;
                }
            }
        }
    }
}

/**
*URLFetchService包装器，确保仅调度10个同步异步获取请求。如果
*如果达到限制，fetchAsync操作将阻塞，直到另一个请求完成。
*/
公共类BlockingURLFetchService实现URLFetchService{
私有最终静态int MAX_同步异步请求=10；
私有最终URLFACHTSERVICE URLFACHTSERVICE=URLFACHTServiceFactory.GetURLFACHTSERVICE（）；
private final Queue activeFetches=new LinkedList（）；
@凌驾
公共HTTPResponse获取（URL）引发IOException{
返回urlFetchService.fetch（url）；
}
@凌驾
公共HTTPResponse获取（HTTPRequest请求）引发IOException{
返回urlFetchService.fetch（请求）；
}
@凌驾
公共未来fetchAsync（URL）{
block（）；
Future-Future=urlFetchService.fetchAsync（url）；
activeFetches.add（未来）；
回归未来；
}
@凌驾
公共未来fetchAsync（HTTPRequest请求）{
block（）；
Future-Future=urlFetchService.fetchAsync（请求）；
activeFetches.add（未来）；
回归未来；
}
私有无效块（）{
while（activeFetches.size（）>=最大同步异步请求数）{
//已达到最大同步异步请求数；请等待一个请求完成
Iterator it=activeFetches.Iterator（）；
while（it.hasNext（））{
if（it.next（）.isDone（））{
it.remove（）；
打破
}
}
}
}
}

请注意，任何和所有请求都会发生同样的情况。比如在任务队列中吃东西之类的。很明显，如果你的反应非常快（我认为在100毫秒以下），谷歌愿意忍受很多，并且不会抛出这个错误。嗯。。这不会发生在我的应用程序上（我没有看到500个错误）。但我正在处理边境案件，有11-13个电话。根据我的经验，Swizec并没有错。见下面我的答案。