Jak uruchomić polecenie średnio 5 razy na sekundę?

Mam skrypt wiersza polecenia, który wykonuje wywołanie interfejsu API i aktualizuje bazę danych o wyniki.

Mam limit 5 wywołań API na sekundę u dostawcy API. Wykonanie skryptu trwa dłużej niż 0,2 sekundy.

• Jeśli uruchomię polecenie sekwencyjnie, nie będzie ono działać wystarczająco szybko i będę wykonywać tylko 1 lub 2 wywołania API na sekundę.
• Jeśli uruchomię polecenie sekwencyjnie, ale jednocześnie z kilku terminali, mogę przekroczyć limit 5 połączeń / sekundę.

Czy istnieje sposób na uporządkowanie wątków, aby mój skrypt wiersza polecenia był wykonywany prawie dokładnie 5 razy na sekundę?

Na przykład coś, co działałoby z 5 lub 10 wątkami i żaden wątek nie wykonałby skryptu, jeśli poprzedni wątek wykonał go mniej niż 200 ms temu.

W systemie GNU, a jeśli tak pv, możesz:

cmd='
   that command | to execute &&
     as shell code'

yes | pv -qL10 | xargs -n1 -P20 sh -c "$cmd" sh

Należy -P20wykonać najwyżej 20 $cmdjednocześnie.

-L10 ogranicza szybkość do 10 bajtów na sekundę, więc 5 linii na sekundę.

Jeśli twoje $cmds stają się dwa wolne i powodują osiągnięcie limitu 20, wtedy xargsprzestaną czytać, aż $cmdprzynajmniej jedna instancja powróci. pvnadal będzie zapisywać do potoku z tą samą szybkością, aż potok się zapełni (co w systemie Linux z domyślnym rozmiarem potoku 64KiB zajmie prawie 2 godziny).

W tym momencie pvprzestanie pisać. Ale nawet wtedy, gdy xargswznowi czytanie, pvspróbuje nadrobić zaległości i wyśle ​​wszystkie wiersze, które powinien był wysłać wcześniej, tak szybko, jak to możliwe, aby utrzymać ogólną średnią 5 linii na sekundę.

Oznacza to, że tak długo, jak to możliwe, przy 20 procesach, aby spełnić te wymagania średnio 5 uruchomień na sekundę, będzie to robić. Jednak gdy limit zostanie osiągnięty, szybkość, z jaką uruchamiane są nowe procesy, nie będzie sterowana przez timer pv, ale przez szybkość, z jaką wracają wcześniejsze instancje cmd. Na przykład, jeśli 20 jest aktualnie uruchomionych i działało przez 10 sekund, a 10 z nich decyduje się zakończyć wszystkie w tym samym czasie, wtedy 10 nowych zostanie uruchomionych jednocześnie.

Przykład:

$ cmd='date +%T.%N; exec sleep 2'
$ yes | pv -qL10 | xargs -n1 -P20 sh -c "$cmd" sh
09:49:23.347013486
09:49:23.527446830
09:49:23.707591664
09:49:23.888182485
09:49:24.068257018
09:49:24.338570865
09:49:24.518963491
09:49:24.699206647
09:49:24.879722328
09:49:25.149988152
09:49:25.330095169

Średnio będzie to 5 razy na sekundę, nawet jeśli opóźnienie między dwoma cyklami nie zawsze będzie wynosić dokładnie 0,2 sekundy.

Za pomocą ksh93(lub za pomocą, zshjeśli twoje sleeppolecenie obsługuje ułamkowe sekundy):

typeset -F SECONDS=0
n=0; while true; do
  your-command &
  sleep "$((++n * 0.2 - SECONDS))"
done

Nie ogranicza to jednak liczby współbieżnych your-command.

Upraszczając, jeśli twoje polecenie trwa krócej niż 1 sekundę, możesz po prostu uruchomić 5 poleceń na sekundę. Oczywiście jest to bardzo brutalne.

while sleep 1
do    for i in {1..5}
      do mycmd &
      done
done

Jeśli twoje polecenie może potrwać dłużej niż 1 sekundę i chcesz rozłożyć polecenia, możesz spróbować

while :
do    for i in {0..4}
      do  sleep .$((i*2))
          mycmd &
      done
      sleep 1 &
      wait
done

Alternatywnie możesz mieć 5 oddzielnych pętli, które działają niezależnie, z minimum 1 sekundą.

for i in {1..5}
do    while :
      do   sleep 1 &
           mycmd &
           wait
      done &
      sleep .2
done

Dzięki programowi C

Możesz na przykład użyć wątku, który śpi przez 0,2 sekundy

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid;

void* doSomeThing() {
    While(1){
         //execute my command
         sleep(0.2)
     } 
}

int main(void)
{
    int i = 0;
    int err;


    err = pthread_create(&(tid), NULL, &doSomeThing, NULL);
    if (err != 0)
        printf("\ncan't create thread :[%s]", strerror(err));
    else
        printf("\n Thread created successfully\n");



    return 0;
}

użyj go, aby wiedzieć, jak utworzyć wątek: utwórz wątek (to jest link, którego użyłem do wklejenia tego kodu)

Za pomocą node.js możesz uruchomić pojedynczy wątek, który wykonuje skrypt bash co 200 milisekund, bez względu na to, jak długo odpowiedź wraca, ponieważ odpowiedź pochodzi z funkcji wywołania zwrotnego .

var util = require('util')
exec = require('child_process').exec

setInterval(function(){
        child  = exec('fullpath to bash script',
                function (error, stdout, stderr) {
                console.log('stdout: ' + stdout);
                console.log('stderr: ' + stderr);
                if (error !== null) {
                        console.log('exec error: ' + error);
                }
        });
},200);

Ten skrypt javascript jest uruchamiany co 200 milisekund, a odpowiedź jest uzyskiwana przez funkcję wywołania zwrotnego function (error, stdout, stderr).

W ten sposób możesz kontrolować, że nigdy nie przekracza 5 wywołań na sekundę niezależnie od tego, jak powolne lub szybkie jest wykonanie polecenia lub ile musi czekać na odpowiedź.

Od pvjakiegoś czasu korzystam z rozwiązania opartego na Stéphane Chazelas , ale odkryłem, że po jakimś czasie, gdziekolwiek od kilku minut do kilku godzin, wyszedł losowo (i cicho). - Edycja: Powodem było to, że mój skrypt PHP czasami umarł z powodu przekroczenia maksymalnego czasu wykonania, wychodząc ze statusem 255.

Postanowiłem więc napisać proste narzędzie wiersza polecenia, które robi dokładnie to, czego potrzebuję.

Osiągnięcie mojego pierwotnego celu jest tak proste, jak:

./parallel.phar 5 20 ./my-command-line-script

Uruchamia prawie dokładnie 5 poleceń na sekundę, chyba że jest już 20 współbieżnych procesów, w którym to przypadku pomija kolejne wykonanie, dopóki nie zostanie udostępnione miejsce.

To narzędzie nie jest wrażliwe na wyjście o statusie 255.