Finagle No asyncronous executing

i have a simple finagle thrift server:

import com.twitter.finagle.Thrift
import scala.concurrent.Future

import com.twitter.util.{ Await, Future }
object Main{

  def main(args: Array[String]) {

    var count = 0

    val myserver = Thrift.serveIface("0.0.0.0:9090", new RealTimeDatabasePageImpressions[com.twitter.util.Future] {

      def saveOrUpdate(pageImpression: PageImpressions):
      com.twitter.util.Future[Boolean] = {
    count += 1
    println(count)
    com.twitter.util.Future.value(true)
      }
    }

   Await.ready(myserver)
  }

}

This server works but i have one big problem: i wrote a thrift nodejs client with a for loop. It executes 10.000 thrift request. But it's not asynchronous. It executes 500 request and stops. After a while, 2 or 3 seconds, 300 more requests will executed. Now the question: Why this happen? Is something wrong with my server or client? I use only the apache thrift generated nodejs code. No wrapper. The function executed 10.000 times. I think the nodejs isn't the problem:

function callFunc(i){
    console.log("started executing: " + i);
    var connection = thrift.createConnection("IP", 9090, {
    transport: transport,
    protocol: protocol
    });

    connection.on('error', function (err) {
    console.log(err);
    });

    // Create a Calculator client with the connection
    var client = thrift.createClient(Realtime_pageImpressions, connection);


    var rand = Math.random() * (20000 - 1);

    var trackId = trackIds[Math.round(Math.random() * 10)];
    var values = new PageImpressions({
    trackId: trackId,
    day: 4,
    hour: 4,
    minute: 13,
    pageId: 'blabla',
    uniqueImpressions: Math.random() * (13000 - 1),
    sumImpressions: Math.random() * (1000450 - 1)
    });

    client.saveOrUpdate(values, function (error, message) {
    if (message) {
        console.log("Successful, got Message: " + message);
    } else {
        console.log("Error with Message: " + error);
    }
    });
    return true;
}
for(var i = 0; i < 10000; i++){
    callFunc(i);
}

Your var count is unsynchronized. This is a very big problem, but, probably, not related to your performance issue. You are also blocking finagle thread, which is also a big problem, but does not matter in your mock case, because there is no wait time.

Think about it this way. Let's say, you have one cpu (you probably have several, but there are other things going on the machine as well), and you are asking it to execute 10000 operations all at the same time.

How can this work? It will have to execute one of the requests, save the context, the stack, flush all caches, switch to the next request, execute that one ...

500 requests in 2 seconds is 4 milliseconds per request. Does not sound that bad, does it?

Also, have you turned your GC (on both server and client)? If requests are processed in bursts followed by long pauses, that's probably a sign of full GC kicking in