Functie Queue

Door Remco , 16 jaar geleden, 2.932x bekeken

Hiermee kun je functies op een later tijdstip laten draaien, je roept de functie aan om een nieuw item toe te voegen en op een later moment roep je de functie aan die alles controleerd. Eventueel kun je met socketTime() te weten komen hoe lang het duurt voordat de volgende in de wachtrij aan de beurt is. (die naam is vanwege een script wat ik aan het maken ben ..)

Gesponsorde koppelingen

PHP script bestanden

  1. functie-queue

 

Er zijn 13 reacties op 'Functie queue'

PHP hulp
PHP hulp
0 seconden vanaf nu
 

Gesponsorde koppelingen
- -
- -
16 jaar geleden
 
0 +1 -0 -1
Je zou ons een lol doen als je het in -tags zou plaatsen :)
Remco
Remco
16 jaar geleden
 
0 +1 -0 -1
Tadaa. Heb net gefrustreerd de FAQ doorgekeken en 2x de verkeerde code gebruikt. -_-
Lode
Lode
16 jaar geleden
 
0 +1 -0 -1
netjes uitgevoerd...
Misschien dat sommige mensen een voorbeeld op prijs stellen.

ik heb zelf zoiets maar dan middels een database om processen te batchen / queuen voor FFMPEG en dergelijke...

voor classes e.d. gebruik ik dan liever een Observer of ChainOfCommand pattern... dat is veel simpeler...

EDIT:
is meer OOP gerelateerd eigenlijk ipv functie gerelateerd:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?php
interface observer{
    public function run();
}

class subject{
    
    protected $observers = array();
    
    public function attach(observer $ob){
        $this->observers[] = $ob;
    }

    public function detach(observer $ob){
        foreach ($this->observers as $key => $observer){
            if($observer == $ob){
                unset($this->observers[$key]);
            }
        }
    }

    public function dispatch(){
        foreach ($this->observers as $observer){
            $observer->run();
        }
    }
}

class ob1 implements observer{
    
    public function run(){
        echo __CLASS__.'->'.__FUNCTION__.'<br/>'.PHP_EOL;
    }
}

class ob2 implements observer{
    
    public function run(){
        echo __CLASS__.'->'.__FUNCTION__.'<br/>'.PHP_EOL;
    }
}

class ob3 implements observer{
    
    public function run(){
        echo __CLASS__.'->'.__FUNCTION__.'<br/>'.PHP_EOL;
    }
}


$s = new subject();
$s->attach(new ob1());
$s->attach(new ob2());

//using methods...
$ob = new ob3;
//$ob2->func($param);
$s->attach($ob);

$s->detach($ob);

$s->dispatch();
?>


SPL bied een standaard oplossing voor een observer...
Jelmer -
Jelmer -
16 jaar geleden
 
0 +1 -0 -1
Oeps, schoonheidsfoutje:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
private static function processItem( $queueId )
...
$this -> queueFarm [ $queueId ];

Binnen static methods bestaat geen $this, want static methods zijn niet instance-gebonden.

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
if( !is_string( $class ) ) {
    $class = get_class( $class );
}

Ik zou zelf controleren of $class een object is of niet. Zo ja, get_class erover heen. Zo nee, typecasten. Daarna nog even kijken of $class niet naar false evalueert, want dan moet er nog een InvalidArgumentException worden gegooid. Waarom ik het niet zo zou doen als jij het doet? Stel dat ik null of false, of een integer als argument geef, per ongeluk, kan zomaar voorkomen. get_class geeft dan false terug, en waar jij dacht dat $class altijd een string was, is hij dat niet.

Heb je trouwens getest met "class" als naam voor een property? Werkt dat? Bij mij levert dat een parse-error op.
Remco
Remco
16 jaar geleden
 
0 +1 -0 -1
Je hebt gelijk, heb alles aangepast en toen de syntax controle eroverheen gehaald. Nu moet het lukken. :)

@Lode: Ik snap het principe maar in mijn geval is deze manier van doen toch makkelijker, het gaat een ramp worden bij mij om voor elke taak een aparte klasse aan te maken .. En een voorbeeld hierbij? Ik denk niet dat er iets is om een voorbeeld voor te geven, er wordt niks aan output gedaan etc. Het principe lijkt me duidelijk, toch?
Crispijn -
Crispijn -
16 jaar geleden
 
0 +1 -0 -1
Als ik een actie wil dan wil ik het meteen... anders stel ik wel een cronjob in. Ik snap dus niet precies wat je hier mee wilt en een voorbeeld kan zeker handig zijn. Al is het maar een voorbeeld script...
Lode
Lode
16 jaar geleden
 
0 +1 -0 -1
Ja voor mij is het duidelijk ja. Maar als ik kijk wat ik altijd voor commentaar krijg denk ik dat er mensen in hun haar gaan krabben...
En dat waren veeeeel simpelere scriptjes.

In jou script forceer je ook met een callback class object van farmIndex.
Ik heb nog even wat verder gekeken en een aantal kanttekeningen.

- geen controle time <> max_execution_time.
- exception > gebruik SPL exceptions ?
- singleton:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
<?php
    public static function getInstance()
    {

        //NULL kan je overigens beter met isset(); doen of is_null();
        //en waarom niet gewoon $self::instance ?

        if(!self::$queueFarm instanceof self)
        {

            self::$queueFarm = new self();
        }

        return self::$queueFarm;
    }

?>


- __toString is eigenlijk niet bedoeld voor je gebruik maar om een instance als string te returnen.
- function callback? Voor zover ik kan zien gaat dit toch echt alleen met classes werken ?
- voor params e.d. heb je functies func_get_args(); e.d.

ik heb zelf snel even dit gebakken. Maar het zonnetje schijnt dus ga ik nu niet verder uitwerken, als ik 'm uberhaupt nog uitwerk:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
<?php
/**
 * callback
 * object for queue class.
 *
 * @package queue
 * @example
 * queue_callback::method('get_headers')
 *         ->params('http://www.phphulp.nl', 1)
 *         ->time(0.3);
 */

class queue_callback{
    
    /**
     * $pattern
     * array container for properties and sorting.
     * @var array $pattern
     */

    protected $pattern     = array(
                                    'method' => NULL,
                                    'params' => array(),
                                    'time'     => 0
                                );
    
    /**
     * method
     * static instance creation for chained command
     * accepts functions and key, value pair for classes.
     *
     * @static
     * @access public
     * @param mixed $callback
     * @return object $this
     */

    static public function method(){
        $count         = func_num_args();
        $callback     = func_get_args();

        switch($count){
            case
1    :    
                if(!is_callable($callback[0])){
                    throw new BadFunctionCallException('function '.$callback.' is not callable');
                }

                break;
            case
2    :    
                if(!is_callable(array($callback[0], $callback[1]))){
                    throw new BadMethodCallException('class '.$callback[0].', method '.$callback[1].' is not callable');
                }

                break;
            default    :
    throw new UnexpectedValueException('too many parameters for '.__FUNCTION__);
        }

        return new self($callback);
    }

    /**
     * __construct
     * create instance of class for procedural methods.
     *
     * @magic
     * @access protected
     * @param mixed $method
     * @return void
     */

    protected function __construct($method){
        $this->pattern['method'] = $method;
    }

    /**
     * params
     * add params for the callback method.
     *
     * @access public
     * @param mixed
     * @return object $this
     */

    public function params(){
        $params = func_get_args();
        $this->pattern[__FUNCTION__] = array_merge($this->pattern['params'], $params);
        return $this;
    }

    /**
     * time
     * set time for callback execution.
     * defaults to 0.
     *
     * @access public
     * @param float $time
     * @return void
     */

    public function time($time){
        if(!is_float($time)){
            throw new UnexpectedValueException('$time should be a float!');
        }

        $max = ini_get('max_execution_time');
        if($max > 0 && $time > $max){
            throw new OverflowException($time.' exceeds max execution time of '.$max.'seconds');
        }

        $this->pattern[__FUNCTION__] = $time;
        return $this;
    }
}

?>


Hoop dat je er wat aan hebt...
Remco
Remco
16 jaar geleden
 
0 +1 -0 -1
- geen controle time <> max_execution_time. De klasse is bedoeld voor een irc bot, en als die maar 30 seconden online kan zijn schiet dat niet echt op ..
- exception > gebruik SPL exceptions? Om eerlijk te zijn wist ik niet eens van het bestaan daarvan af, heb je misschien een lijstje met die exceptions? Al gevonden, Google is your best friend.
- singleton: Mwoah, eerlijk gezegd is er geen groot verschil. Op mijn manier werkt het toch ook prima ..
- __toString(). Ik wist niet wat er anders moest staan :$
- function callback. 2e versie ondersteund ook alleen functies.

--

Lode, heb je er problemen mee dat ik je geposte voorbeeld opneem in m'n 2e versie? Ik vind 'm namelijk wel netjes in elkaar zitten.
Lode
Lode
16 jaar geleden
 
0 +1 -0 -1
Als ik daar problemen mee had gehad had ik 'm niet gepost natuurlijk...

met mijn singleton controleer je niet of de property NULL is. Maar dat het ook daadwerkelijk geen instanceof self is. Ik vind dat netter persoonlijk..
new self(); is maakt het iets flexibeler...

verder zou ik ook persoonlijk ook eens kijken naar de Reflection API van php.

en ja google kan je vriend zijn inderdaad:
http://www.justfuckinggoogleit.com/

daarnaast lijk een array mij handiger ipv losse properties. Je kan dan bijvoorbeeld van het totaal een multi dimensionale array van maken en deze sorteren op de tijd e.d.

Een IRC bot... dat heb je nooit vermeld en ik ben niet paranormaal... zou het er iig gewoon inbakken...

Ik zat nog wel even te denken hoe je dat eventueel zou moeten doen als je bij een classe meerdere methods wilt aanroepen... Maar daar is ook wel wat op te verzinnen denk ik...
Remco
Remco
16 jaar geleden
 
0 +1 -0 -1
Hoppatee. 2e versie staar hier nu, heb het principe van Lode toegepast en excepties van spl gebruikt. :)
Lode
Lode
16 jaar geleden
 
0 +1 -0 -1
Nog een kleine toevoeging... :-]

Exceptions == php5+
SPL == php5.2+

dus dit kan geen kwaad:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
/**
 * SPL exceptoins
 * create for versions that don't have SPL available, php versions 5+ < 5.2.
 * @see http://www.php.net/~helly
 */

if(!class_exists('BadFunctionCallException')){
    class BadFunctionCallException extends Exception{}
}

if(!class_exists('BadMethodCallException')){
    class BadMethodCallException extends Exception{}
}

if(!class_exists('UnexpectedValueException')){
    class UnexpectedValueException extends Exception{}
}

if(!class_exists('OverflowException')){
    class OverflowException extends Exception{}
}

?>


version_compare();
phpversion();

zou misschien nog netter zijn..

Sommige SPL onderdelen hebben speciale toegevoegde waarden maar dit kan prima...

Ik ga ook nog wel ff klooien... verveel me toch een beetje...
Rudie dirkx
rudie dirkx
16 jaar geleden
 
0 +1 -0 -1
Ik snap m niet. Waarom zou je ooit functies 'op een later tijdstip' willen uitvoeren in dezelfde load? En waarom zou je ooit een sleep in je php script zetten?
Misschien een voorbeeldje hoe je het echt zou gebruiken..? Niet alleen syntax, maar ook in een context. Danke
PHP hulp
PHP hulp
0 seconden vanaf nu
 

Gesponsorde koppelingen
Remco
Remco
16 jaar geleden
 
0 +1 -0 -1
Ik geef je de exacte reden. Dit script is een deel van mijn nog w.i.p. botje. Het moet in staat zijn om meerdere sockets tegelijk te behandelen. Daarnaast lopen er ook nog timers in het script, deze timers worden in deze queue geplaatst. Ik weet niet of je verstand hebt van sockets etc. maar je moet ze pollen met socket_select() wil je dit idee realiseren. De functie slikt als laatste 2 parameters de maximale tijd waarop hij mag wachten voor sockets. Nu kun je een groot getal invoeren ( 200 sec. ) maar dan heb je kans dat in de tussentijd timers moeten worden aangeroepen. Met dit script kun je dus de tijd berekenen voordat de volgende timer aan bod komt, en die tijd gebruiken voor de socket_select() functie.

Klinkt waarschijnlijk behoorlijk ingewikkeld, maar geloof me, het is echt nodig. ;)

Om te reageren heb je een account nodig en je moet ingelogd zijn.

Inhoudsopgave

  1. functie-queue

Labels

  • Geen tags toegevoegd.

Navigatie

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.