CORBA choses peu claires

Question

J'ai récemment commencé à travailler sur mon premier projet CORBA. Je pense que j'ai les choses de base, mais il y a des choses qui m'échappent encore. Une de ces choses est de savoir comment CORBA gère plusieurs appels sur le même objet. Supposons que j'ai un client qui s'enregistre auprès du serveur, puis peut recevoir du travail. Le serveur envoie du travail à des moments aléatoires.

• Tous ces appels sont-ils traités sur le même thread? Cela signifierait que pendant que le client travaille, il ne peut rien recevoir. Dans ce cas, comment pourrais-je lui donner un comportement multithread.

  • Ou d'un autre côté, un thread est-il généré pour chaque appel reçu? Dans ce cas dois-je protéger les données communes accessibles à chaque appel? Quelle serait une bonne pratique de le faire

Autre chose que je voudrais faire est de créer plusieurs travailleurs et de les recevoir du travail, mais dans ma mise en œuvre qu'un seul travailleur est actif.

Ci-dessous:

public static void main(String[] args) 
{  
    try 
    { 
    connectWithServer(args);     
     createWorkers();    
     // wait for invocations from clients 
     orb.run(); 
    } 
    catch (Exception e) 
    { 
     System.out.println("ERROR : " + e) ; 
     e.printStackTrace(System.out); 
    } 
} 

static public void connectWithServer(String[] args)throws Exception 
{ 
     orb = ORB.init(args, null); 

     // get reference to rootpoa & activate the POAManager 
     rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 
     rootpoa.the_POAManager().activate(); 

     // get the root naming context 
     org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); 

     // Use NamingContextExt instead of NamingContext. This is 
     // part of the Interoperable naming Service. 
     NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); 

     // resolve the Object Reference in Naming 
     taskBagImpl = TaskBagHelper.narrow(ncRef.resolve_str(SERVER_NAME));  

     System.out.println(TAG + " Obtained a handle on server object: " + taskBagImpl);   
    } 



public static void createWorkers() throws Exception 
    { 
     for(int i = 0; i < nrOfWorkers; i++) 
     { 
      WorkerImpl w = new WorkerImpl(); 
      rootpoa.activate_object((Servant) w); 
      Worker ref = WorkerHelper.narrow(rootpoa.servant_to_reference(w)); 

      w.setRef(ref); 

      taskBagImpl.registerWorker(w.getId(), ref);    
     } 
    } 

Answer 1

Options Threading ne sont pas spécifiées dans la norme CORBA. La seule configuration possible en matière de threading est la politique POA ThreadingPolicy. Les valeurs possibles sont ORB_CTRL_MODEL ou SINGLE_THREAD_MODEL. Le premier ne spécifie rien sur le thread et l'implémentation ORB décide du modèle de thread à utiliser. Ce dernier garantit que chaque requête reçue par un objet (dans le même POA) est sérialisée, donc aucune fonctionnalité de réentrée ou de multi-threading ne doit être implémentée dans le serviteur. Cependant, les implémenteurs CORBA ont pris connaissance de cette limitation et ont implémenté des règles standard par défaut, qui doivent être configurées par d'autres moyens (par exemple des options de programme via ORB.init() ou des fichiers de configuration). Habituellement, vous pouvez trouver trois politiques différentes (une fois que vous sélectionnez ORB_CTRL_MODEL):

• Discussion par demande: un nouveau thread Spawns chaque demande.
• Thread par client: génère un nouveau thread pour chaque client différent.
• Thread pool: l'ORB pré-alloue un pool de threads et les utilise pour servir toutes les requêtes.

D'autres sont possibles, mais ceux-ci ont tendance à être le terrain commun. De couse, l'un ou l'autre vous obligera à utiliser n'importe quel type de stratégie de verrouillage pour soutenir les clients simultanés.

Answer 2

Voir cette FAQ Java IDL:

What is the thread model supported by the CORBA implementation in this release?