Ankündigung

Einklappen
Keine Ankündigung bisher.

Thread Fehlerbehandlung

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Thread Fehlerbehandlung

    PHP-Code:
    <?php
       error_reporting
    (~0);
       
       class 
    extends Thread // PECL-Extension pthreads
       
    {
          private 
    $oSuccessCallback;
          private 
    $oFaultCallback;
          private 
    $i;

          
    /**
           * @param SuccessCallback $oSuccessCallback
           * @param FaultCallback $oFaultCallback
           * @param int $i eindeutige Thread-Nummer
           */
          
    function __construct(SuccessCallback $oSuccessCallbackFaultCallback $oFaultCallback$i)
          {
             
    $this->oSuccessCallback $oSuccessCallback;
             
    $this->oFaultCallback $oFaultCallback;
             
    $this->$i;
          }

          
    /**
           * @return int eindeutige Thread-Nummer
           */
          
    function getI()
          {
             return 
    $this->i;
          }
          
          
    /**
           * Thread starten und geworfene Exceptions abfangen.
           * Wird automatisch mit start() aufgerufen.
           */
          
    function run()
          {
             try
             {
                echo 
    'start'.PHP_EOL;
                
                
    // error triggern:
                
    gibtEsNicht(); // Die Fatal error Ausgabe könnte man mit @ unterdrücken.
                
                // Exception werfen:
                //throw new Exception('xxx');
                
                
    echo 'end'.PHP_EOL;
                
    $this->oSuccessCallback->done($this);
             }
             catch(
    Exception $oE)
             {
                
    // Exceptions abfangen:
                
    $this->oFaultCallback->exception($this$oE);
             }
          }
       }
       
       class 
    SuccessCallback
       
    {
          
    /**
           * Wird automatisch vom Thread aufgerufen, wenn er erfolgreich beendet wurde.
           */
          
    function done(Threaded $oThreaded
          { 
             echo 
    $oThreaded->getI()." cuccess\n"
          }
       }
       
       
    /** 
        * Fehlerbehandlung.
        */
       
    class FaultCallback
       
    {
          
    /**
           * Wird automatisch vom Thread aufgerufen, wenn ein error getriggert wurde.
           * @param Threaded $oThreaded
           */
          
    function error(Threaded $oThreaded)
          {
             echo 
    $oThreaded->getI()." error\n";
             
    var_dump($oThreaded->getTerminationInfo());
          }  
          
    /**
           * Wird automatisch vom Thread aufgerufen, wenn eine geworfen wurde.
           * @param Threaded $oThreaded
           * @param Exception $oE
           */       
          
    function exception(Threaded $oThreadedException $oE)
          {
             echo 
    $oThreaded->getI()." exception\n";
             
    var_dump($oE);
          }
          
    // Kann bei Bedarf um weitere Exception-Methoden erweitert werden.
       
    }
       
       class 
    ThreadWrapper
       
    {
          
    /**
           * Thread starten und getriggerte errors abfangen.
           * @param SuccessCallback $oSuccessCallback
           * @param FaultCallback $oFaultCallback
           * @param int $i eindeutige Thread-Nummer
           */
          
    function start(SuccessCallback $oSuccessCallbackFaultCallback $oFaultCallback$i)
          {
             
    $oT = new T($oSuccessCallback$oFaultCallback$i);
             
    $oT->start(); // Die Fatal error Ausgabe könnte man mit @ unterdrücken.
             // Wirft run() eine Exception, kann die danach nicht mehr mit try-catch abgefangen werden.
             // Statt die Exception weiterzugeben, wird ein Fatal error getriggert.
             // Der könnte unterdrückt werden, indem man start() ein @ voranstellt.
             // isTerminated() erkennt den error dann trotzdem noch.

             // errors abfangen:
             
    $oT->join(); // warten, bis der Thread zu Ende ist
             
    if($oT->isTerminated())
             {
                
    $oFaultCallback->error($oT);
             }
          }
       }
       
       
    $oSuccessCallback = new SuccessCallback();
       
    $oFaultCallback = new FaultCallback();
       
    $oT = new ThreadWrapper();
       
    $oT->start($oSuccessCallback$oFaultCallback1); 
    ?>
    Kann man die Fehlerbehandlung noch irgendwie vereinfachen?


  • #2
    Vielleicht. Mit was genau bist du denn noch nicht zufrieden?

    Btw, das ?> am Ende solltest du weglassen. Es ist syntaktisch nicht notwendig ("Blinddarm") und erzeugt potentiell ungewollte Ausgaben.
    Standards - Best Practices - AwesomePHP - Guideline für WebApps

    Kommentar


    • #3
      Ich kenn mich mit dem Thema Threads noch nicht aus.

      Vielleicht kann man das auch alles viel einfacher oder besser mit irgendwelchen schon zur Verfügung stehenden Methoden machen.

      Vielleicht ergeben sich auch Probleme, wenn man dann mit mehreren Threads arbeiten möchte.

      Vielleicht entspricht dieser Programmierstil auch gar nicht jenen Stilen, die man aus anderen Programmiersprachen kennt.

      Darum frage ich nach.

      Kommentar


      • #4
        Was willst du denn da bauen? Promises?
        Standards - Best Practices - AwesomePHP - Guideline für WebApps

        Kommentar


        • #5
          An irgendwelche asynchronen Verschachtelungen habe ich hier eigentlich noch gar nicht gedacht.

          Aber diese 2 unterschiedlichen Callbacks für success und error (heißt bei mir fault, damit ich zwischen getriggerten errors und geworfenen Exceptions unterscheiden kann) habe ich auch.

          Kommentar

          Lädt...
          X