add

int \Workerman\Timer::add(float $time_interval, callable $callback [,$args = array(), bool $persistent = true])

Esegue periodicamente una funzione o un metodo di classe.

Attenzione: il timer viene eseguito nel processo corrente, workerman non creerà nuovi processi o thread per eseguire il timer.

Parametri

time_interval

Dopo quanto tempo eseguire di nuovo, in secondi, supporta i decimali e può essere preciso fino a 0.001, cioè a livello millisecondo.

callback

Funzione di callback Attenzione: se la funzione di callback è un metodo di classe, il metodo deve essere pubblico

args

Parametri della funzione di callback, deve essere un array, gli elementi dell'array sono i valori dei parametri.

persistent

Se è persistente; se desideri eseguire il task solo una volta, passa false (le attività eseguite una sola volta verranno automaticamente distrutte dopo l'esecuzione, non è necessario chiamare Timer::del()). Il valore predefinito è true, cioè verrà eseguito periodicamente.

Valore di ritorno

Restituisce un intero che rappresenta l'ID del timer, puoi distruggere questo timer chiamando Timer::del($timerid).

Esempio

1. Funzione temporizzata come funzione anonima (closure)

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

$task = new Worker();
// Imposta quanti processi eseguono il task temporizzato, fai attenzione a eventuali problemi di concorrenza in più processi
$task->count = 1;
$task->onWorkerStart = function(Worker $task)
{
    // Esegui ogni 2,5 secondi
    $time_interval = 2.5;
    Timer::add($time_interval, function()
    {
        echo "task run\n";
    });
};

// Esegui worker
Worker::runAll();

2. Imposta il timer solo nel processo specificato

Un'istanza worker ha 4 processi, imposta il timer solo nel processo con ID 0.

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker();
$worker->count = 4;
$worker->onWorkerStart = function(Worker $worker)
{
    // Imposta il timer solo nel processo con ID 0, gli altri processi 1, 2, 3 non impostano un timer
    if($worker->id === 0)
    {
        Timer::add(1, function(){
            echo "4 processi worker, timer impostato solo nel processo 0\n";
        });
    }
};
// Esegui worker
Worker::runAll();

3. Funzione temporizzata come funzione anonima, utilizza la closure per passare i parametri

use Workerman\Worker;
use Workerman\Timer;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';

$ws_worker = new Worker('websocket://0.0.0.0:8080');
$ws_worker->count = 8;
// Durante la creazione della connessione, imposta il timer per la connessione corrispondente
$ws_worker->onConnect = function(TcpConnection $connection)
{
    // Esegui ogni 10 secondi
    $time_interval = 10;
    $connect_time = time();
    // Aggiungi temporaneamente un attributo timer_id all'oggetto connection per salvare l'ID del timer
    $connection->timer_id = Timer::add($time_interval, function()use($connection, $connect_time)
    {
         $connection->send($connect_time);
    });
};
// Quando la connessione si chiude, elimina il timer corrispondente
$ws_worker->onClose = function(TcpConnection $connection)
{
    // Elimina il timer
    Timer::del($connection->timer_id);
};

// Esegui worker
Worker::runAll();

4. Funzione temporizzata come funzione anonima, utilizza l'interfaccia del timer per passare i parametri

use Workerman\Worker;
use Workerman\Timer;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';

$ws_worker = new Worker('websocket://0.0.0.0:8080');
$ws_worker->count = 8;
// Durante la creazione della connessione, imposta il timer per la connessione corrispondente
$ws_worker->onConnect = function(TcpConnection $connection)
{
    // Esegui ogni 10 secondi
    $time_interval = 10;
    $connect_time = time();
    // Aggiungi temporaneamente un attributo timer_id all'oggetto connection per salvare l'ID del timer
    $connection->timer_id = Timer::add($time_interval, function($connection, $connect_time)
    {
         $connection->send($connect_time);
    }, array($connection, $connect_time));
};
// Quando la connessione si chiude, elimina il timer corrispondente
$ws_worker->onClose = function(TcpConnection $connection)
{
    // Elimina il timer
    Timer::del($connection->timer_id);
};

// Esegui worker
Worker::runAll();

5. Funzione temporizzata come funzione normale

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

// Funzione normale
function send_mail($to, $content)
{
    echo "invio email ...\n";
}

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    $to = 'workerman@workerman.net';
    $content = 'hello workerman';
    // Esegui il task di invio email dopo 10 secondi, l'ultimo parametro è false, indica che deve essere eseguito solo una volta
    Timer::add(10, 'send_mail', array($to, $content), false);
};

// Esegui worker
Worker::runAll();

6. Funzione temporizzata come metodo di classe

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

class Mail
{
    // Attenzione, la funzione di callback deve essere pubblica
    public function send($to, $content)
    {
        echo "invio email ...\n";
    }
}

$task = new Worker();
$task->onWorkerStart = function($task)
{
    // Invia un'email dopo 10 secondi
    $mail = new Mail();
    $to = 'workerman@workerman.net';
    $content = 'hello workerman';
    Timer::add(10, array($mail, 'send'), array($to, $content), false);
};

// Esegui worker
Worker::runAll();

7. Funzione temporizzata come metodo di classe (utilizzo del timer all'interno della classe)

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

class Mail
{
    // Attenzione, la funzione di callback deve essere pubblica
    public function send($to, $content)
    {
        echo "invio email ...\n";
    }

    public function sendLater($to, $content)
    {
        // Se il metodo di callback appartiene alla classe corrente, il primo elemento dell'array di callback sarà $this
        Timer::add(10, array($this, 'send'), array($to, $content), false);
    }
}

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    // Invia un'email dopo 10 secondi
    $mail = new Mail();
    $to = 'workerman@workerman.net';
    $content = 'hello workerman';
    $mail->sendLater($to, $content);
};

// Esegui worker
Worker::runAll();

8. Funzione temporizzata come metodo statico della classe

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

class Mail
{
    // Attenzione, questo è un metodo statico, la funzione di callback deve essere pubblica
    public static function send($to, $content)
    {
        echo "invio email ...\n";
    }
}

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    // Invia un'email dopo 10 secondi
    $to = 'workerman@workerman.net';
    $content = 'hello workerman';
    // Chiama periodicamente il metodo statico della classe
    Timer::add(10, array('Mail', 'send'), array($to, $content), false);
};

// Esegui worker
Worker::runAll();

9. Funzione temporizzata come metodo statico della classe (con namespace)

namespace Task;

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

class Mail
{
    // Attenzione, questo è un metodo statico, la funzione di callback deve essere pubblica
    public static function send($to, $content)
    {
        echo "invio email ...\n";
    }
}

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    // Invia un'email dopo 10 secondi
    $to = 'workerman@workerman.net';
    $content = 'hello workerman';
    // Chiama periodicamente un metodo statico della classe con namespace
    Timer::add(10, array('\Task\Mail', 'send'), array($to, $content), false);
};

// Esegui worker
Worker::runAll();

10. Distruggi il timer corrente all'interno del timer (passa $timer_id con use closure)

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    // Conteggio
    $count = 1;
    // Per passare correttamente $timer_id all'interno della funzione di callback, $timer_id deve essere preceduto dall'operatore di indirizzo &
    $timer_id = Timer::add(1, function()use(&$timer_id, &$count)
    {
        echo "Timer run $count\n";
        // Dopo 10 esecuzioni, distruggi il timer corrente
        if($count++ >= 10)
        {
            echo "Timer::del($timer_id)\n";
            Timer::del($timer_id);
        }
    });
};

// Esegui worker
Worker::runAll();

11. Distruggi il timer corrente all'interno del timer (passa $timer_id con parametri)

use Workerman\Worker;
use Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';

class Mail
{
    public function send($to, $content, $timer_id)
    {
        // Aggiungi temporaneamente un attributo count all'oggetto corrente per tenere traccia delle volte che il timer è stato eseguito
        $this->count = empty($this->count) ? 1 : $this->count;
        // Dopo 10 esecuzioni, distruggi il timer corrente
        echo "invio email {$this->count}...\n";
        if($this->count++ >= 10)
        {
            echo "Timer::del($timer_id)\n";
            Timer::del($timer_id);
        }
    }
}

$task = new Worker();
$task->onWorkerStart = function(Worker $task)
{
    $mail = new Mail();
    // Per passare correttamente $timer_id alla funzione di callback, $timer_id deve essere preceduto dall'operatore di indirizzo &
    $timer_id = Timer::add(1, array($mail, 'send'), array('to', 'content', &$timer_id));
};

// Esegui worker
Worker::runAll();