Forums : Xul, Xbl, JS...

J'ai écrit une petite classe pour créer des threads en javascript. Entre autre elle récupère un proxy sur le service de notification, au niveau de la fonction run

/*! Thread constructor
 */
function Thread() {
    this.ThreadService = Components.classes["@mozilla.org/thread;1"].getService(Components.interfaces.nsIThread);
    this.proxyObserverService = null;
}


Thread.prototype = {
    /*! Start the thread
     */
    start: function() {
        this.ThreadService.init(this, 1024, Components.interfaces.nsIThread.PRIORITY_NORMAL, Components.interfaces.nsIThread.SCOPE_GLOBAL, Components.interfaces.nsIThread.STATE_UNJOINABLE);
    },



    /*! Main thread function. Get a proxy object for the observer service
     * and call execute method
     */
    run: function() {
        var ObserverService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);

        const nsIEventQueueService = Components.interfaces.nsIEventQueueService;
        var eqService = Components.classes["@mozilla.org/event-queue-service;1"].getService(nsIEventQueueService);
        var uiQ = eqService.getSpecialEventQueue(nsIEventQueueService.UI_THREAD_EVENT_QUEUE);

        var proxyObjectManager = Components.classes["@mozilla.org/xpcomproxy;1"].getService(Components.interfaces.nsIProxyObjectManager);
        var proxyType = proxyObjectManager.INVOKE_ASYNC | proxyObjectManager.FORCE_PROXY_CREATION;
        this.proxyObserverService = proxyObjectManager.getProxyForObject(uiQ, Components.interfaces.nsIObserverService, ObserverService, proxyType);

        this.execute();
    },



    /*! Thread function. Should be overrided
     */
    execute: function() {
    }

};

Je me permets de remonter ce fil, car j'aimerai bien arriver à comprendre le fonctionnement des threads.

Il est dit que le thread ne peut interagir avec rien, surtout pas le DOM. Comment peut-il alors envoyer des informations vers l'interface XUL ? L'exemple d'un long traitement pouvant être suivi par une barre de progression me semble un cas intéressant pour illustrer ma question.

Il a été dit aussi qu'on ne pouvait pas mettre en pause un thread. Peut on au moins l'arrêter, et comment ? Est-ce que l'interface XUL peut transmettre des données à un thread en cours d'exécution ?

(vi, je pose trop de questions )

Un thread peut intégragir avec l'interface avec les objets proxyfiés.

Un objet proxyfié est un un mutex qui ne dit pas son nom et est associé à une "Event Queue" associé au thread cible (le thread auquel l'objet proxifié appartient. Le thread peut alors communiquer en mode "bloquant" (il appelle la fonction de l'objet proxifié dans le thread principal puis attend la fin de l'éxecution de celle-ci). Ou en mode "non bloquant" , la méthode de l'objet proxifié est executée dans le thread principal mais le thread appelant n'attend pas la fin de son exécution et continue son bonhomme de chemin..

On ne peut pas mettre en pause un thread de l'exterieur.

La communication entre un thread et l'interface XUL (le thread principal) peut se faire dans les deux sens à condition de créer une "Event queue" pour le thread auquel on veut associer des objets proxifiés.

J'ai un exemple de filtrage de donnée dans un thread avec une barre de progression. Il est basé sur la classe que j'ai mentionnée un peu plus haut.

Je l'utilise pour trier un tableau de messages de log en fonction du log level. Voila en gros le code, c'est du copier collé avec quelques modifications, donc il y a des ajustements a faire mais l'idée est la.

Observer côté XUL :

 var obj = {
   filterProgressMeter: null, //reference sur la progress bar
 
   displayedLogs: null, //tableau pour les elements triés
 
   .......
   
   /*! Observe message from the filter thread
    *
    * @param subject unused
    * @param topic The message topic
    * @param data The data for the message
    */
   observe: function(subject, topic, data) {
       if(topic == "progressLogFilter") {
           this.filterProgressMeter.value = data;
 
       } else if(topic == "endLogFilter") {
           this.filterProgressMeter.value = 0;
           this.displayedLogs = this.filterThread.filteredData;
 
           this.refreshView();
           this.removeObservers();
           this.enableCommand(true);
       }
   },
 
   ........
 }

Lancement du thread côté XUL :

 var ObserverService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
 ObserverService.addObserver(this, "progressLogFilter", false);
 ObserverService.addObserver(this, "endLogFilter", false);
 
 var filterThread = new LogFilterThread();
 filterThread.setFilterData(this.logs, this.notice, this.warning, this.error);
 filterThread.start();

Côté Thread

 /*! Constructor for the log filter thread
  *
  */
 function LogFilterThread() {
     this.parent = Thread;
     this.parent();
 }
   
 LogFilterThread.prototype = new Thread();
 
 
 
 /*! Set the filter informations
  *
  * @param data The data to filter
  * @param acceptNotice True if notice log are accepted, false otherwise
  * @param acceptWarning True if warning log are accepted, false otherwise
  * @param acceptError True if error log are accepted, false otherwise
  */
 LogFilterThread.prototype.setFilterData = function(data, acceptNotice, acceptWarning, acceptError) {
     this.initData = data;
     this.filteredData = null;
 
     this.acceptNotice = acceptNotice;
     this.acceptWarning = acceptWarning;
     this.acceptError = acceptError;
 }
   
   
   
 /*! Filter the data
  */
 LogFilterThread.prototype.execute = function() {
     this.filteredData = <logs></logs>;
     
     var l = this.initData.log.length();
     for(var i = 0; i < l; i++) {
         var ok = false;
 
         if(this.initData.log[i].@level == 'notice')
             ok = this.acceptNotice;
 
         else if(this.initData.log[i].@level == 'warning')
             ok = this.acceptWarning;
 
         else if(this.initData.log[i].@level == 'error')
           ok = this.acceptError;
 
         if(ok)
           this.filteredData.log += this.initData.log[i];
 
         //notify for filter progression
         this.proxyObserverService.notifyObservers(this, "progressLogFilter", i * 100 / (l - 1));
     }
 
     //notify for filter termination
     this.proxyObserverService.notifyObservers(this, "endLogFilter", this.filteredData);
 };

Bon, ok, il va falloir que je digère cette masse d'information et que je réussisse à faire quelques tests simples pour bien comprendre. Ensuite, je tacherai de mettre en forme un petit didacticiel sur le wiki

Merci à vous