Nodejs，需要时间的多个请求

Question

i have a question that is keeping me busy and i wondered if anyone might have the answer.

Lets assume that i have an express app that listens for a post request, This post request triggers a function in the program that calls over 1000 times with axios to a service (for that matter an sms provider that with the api call sends an sms message). Now, assuming that one request takes 200 ms for the SMS provider, 1000 of them will take over 2 minutes. Of course i will send a response from the server earlier saying that the request have been recieved. My question is, lets say that there are 20 or even 100 requests of it at the same time, how can i get the app to handle that traffic? Even if it would it will take very long to perform all of those actions.

How can it be performed? Is there a preferd language to do so? Is it possible with node?

Answer 1

If you are broadcasting same sms to many users, you should search for a broadcasting command in the sms api. This would decrease number of operations/bandwidth required on your server.

If broadcasting support doesn't exist, you should let other requests be fetched while processing those sms tasks. Something like:

function smsTask(n)
{
     doSmsWork(function(response){ 
          if(n)
          {
                setTimeout(function(){ 
                    smsTask(n-1);
                },0);
          }
     })
}

smsTask(num);

Between if(n) and smsTask(n-1) , other asynchronous tasks can find time to work, including fetching/intercepting new smsTasks and RAM requirement depends only on number of requests in-flight, not number of sms tasks. If you need to cap the bandwidth for all sms tasks, you can use a dynamical waiting value (instead of 0) for the setTimeout function and this can dedicate more bandwidth to other tasks (like serving web pages, etc) instead of being fully consumed by sms spam.

If you don't ask for asynchronously letting new requests be handled, then you can complete whole work per request much quicker than 2 minutes, if its I/O bound:

function smsTask(n)
{
     for(let i=0;i<n;i++)
         doSmsWork(function(response){ 
          
         })
}

smsTask(num);

in perfect I/O conditions, this can complete within 200ms-300ms even for n=1000. This still doesn't stop new tasks/requests but puts too much pressure on the queue and probably consumes more memory while other version keeps stead memory consumption depending on number of requests in flight only.

If you need even less I/O contention, you can put the tasks into a queue and have a dedicated function for processing the queue:

let work = [];
function smsTask(n){ work.push(some_task(n)); }

setInterval(function(){
    if(work.length > 0)
    {
        let task = work.shift();
        task?.compute(); // does sms work
    }
},1000);

This is steady-state processing and still doesn't stop because of sudden request spikes as long as work queue does not overflow memory. Maybe setTimeout version of this is better for CPU.