4. MUTEX Problem

MUTEX Problem

  • ?

    Hallo alle ...
    Ich hab da so ne kleines problemchen
    Ich habe ein Programm in C++ geschreiben das Outputs in verschiedenen Files erstellt. Dieses Modul wird von verschiedenen Sprachen ( ASM,COBOL,REX,C,und C++ ) aufgerufen natürlich ist das Programm RENT. Dieses Mudul bekommt einen Aufrufparameter in dem unteranderem einige Mutex Objecte enthalten sind die von einem Server erstellt worden sind. Natürlich möchte ich nun mit einem dieser Mutexobjecte die Outputs syncronisieren. Das ist aber schwierig da es ja immer der selbe Owner des Mutexes ist( in anderen worten bei einem Lock des mutexes wartet es nicht wenn es bereits gelockt ist da es für das Mutex ein recrusiver aufruf ist).
    Ich habe dann beim Mutex erstellen das attribut

    pthread_mutexattr_setkind_np(&m_mutexattributTemp,
                             __MUTEX_NONRECURSIVE)

    benutzt. Und das löst fast mein problem ........
    Denn wenn das Mutex nun gelockt ist und ich es versuche nochmal zu locken dann wird errno auf EDEADLK gesetzt. Das bedeutet das ein nicht recrusives Mutexobject recrusive gelockt werden sollte.
    Dann habe ich mir meine eigene lock funktion geschrieben Sie ist nicht gerade Toll aber funzt ich würde aber gerne eine andere Lösung haben da in meiner Lösung das Lock kein Warten auslöst sondern es wir einfach in einem Loop versucht das Mutex zu locken ...

    int  LockMutexObject    ( void* m_ptrMutex , int time)
{
 /**********************************************************************
  * Zu Anfang ich weiss das diese Lösung nicht schön ist aber          *
  * zumindest funktioniert sie für den anfang                          *
  **********************************************************************/

 // Da diese Programm mehrmals und RENT aufgerufen wird muss ich einen 
 // Flaschenhals schaffen da beim Dumpprint immer dieselben 80 Bytes 
 // benutzt werden. Da aber ein Mutex nur dann wartet wenn es von 2 unter-
 // schiedlichen Thread gelockt wird muss ich hier nun die errno Variable
 // nach den Lock abfragen um zu überprüfen ob es bereits gelockt ist.

  if ( pthread_mutex_lock( ((pthread_mutex_t*)m_ptrMutex)) != 0 )
    {
     // falls das Mutex von mir selber bereits gelockt worden und das 
     // Mutexattribut ist NORECRUSIVE dann gibt das lock -1 zurück 
     // und errno wird auf EDEADLK gesetzt     
      if ( errno == EDEADLK )
      {
        // so hier wird nun versucht das Mutex zu Locken unzwar 
        // 'time * 1 Sekunde' 
        for ( int i = 0; i < time; i++ ) 
        {
         // erst mal ne sekundchen warten
         sleep(1);
         // nun versuchen das Mutex zu locken
         if ( pthread_mutex_lock( ((pthread_mutex_t*)m_ptrMutex )) != 0 )
         {
          if ( errno == EDEADLK )
           continue;
          else
          {
           printf("\nEs ist ein Fehler beim locken des SLPASDIS Mutexes");
           printf("aufgetreten");
           return 1;
          }
         }
         else // das mutex wurde erfolgreich gelockt
          return 0;         
        }
        return 1; // das Mutex konnte nicht gelockt werden 
      }
      else
      {
        printf("\nEs ist ein Fehler beim locken des SLPASDIS Mutexes");
        printf("aufgetreten");
        return 1;
       }

    }
    return 0; 
}

    Wäre cool wenn mir einer einen Tipp geben könnte ...
    Bis denne ...
    Leo

    0
  • R

    Ich habe keine Ahnung, was du überhaupt machen willst.

    0
  • ?

    Dann les doch mal meine beschreibung wenn Du das dann immer noch nicht verstehst dann bezweifle ich bei allem Respeckt das Du mir da weiter helfen kannst. Trotzdem Danke für das Interesse...
    bis dann 👍

    0
  • A

    ich kann aus deiner beschreibung auch nicht so wirklich dein problem
    herausfiltern.

    erstmal: ist das ganze multithreaded oder nicht ?

    dann ist pthread_mutexattr_setkind_np() deprecated und durch
    pthread_mutexattr_settype() ersetzt worden.

    ausserdem sind pthread_mutexe AFAIK per default non-recursive, wenn sie nicht explizit auf recursive gesetzt werden.

    wo hast du denn dieses '__MUTEX_NONRECURSIVE' her ?

    wenn du im gleichen thread den gleichen lock non-recursive
    machst bekommst du einen deadlock. wenn error-checking
    enabled ist gibts den EDEADLK und pthread_mutex_lock()
    kehrt zurück.
    kein wunder also wenn dein thread nicht wartet.

    0
  • ?

    1. Der Source lauft auf dem Z/OS ( OS/390) Mainframe ...
    2. Der Source läuft reentrend (RENT) das bedeutet das das Programm mehrmals gleichzeitig läuft. Aus diesem Grund muss ich es auch schaffen das der beim Lock wartet.

    Ist ja cool wenn der nicht wartet nur wie krig ich den zum warten ohne das ich den loop durchlaufe. ( ich steh nicht so auf loops ) da muss es doch eine ander Lösung geben ....

    0
  • A

    LEO 3 schrieb:

    1. Der Source lauft auf dem Z/OS ( OS/390) Mainframe ...
    2. Der Source läuft reentrend (RENT) das bedeutet das das Programm mehrmals gleichzeitig läuft. Aus diesem Grund muss ich es auch schaffen das der beim Lock wartet.

    _reentrant_. ich weiss was das ist.
    was heisst mehrmals ? mehrere threads oder mehrere prozesse ?

    LEO 3 schrieb:

    Ist ja cool wenn der nicht wartet nur wie krig ich den zum warten ohne das ich den loop durchlaufe. ( ich steh nicht so auf loops ) da muss es doch eine ander Lösung geben ....

    tja, vielleicht besseres design ? oder mal überlegen ob du nicht doch
    rekursives locken zulassen kannst.

    0
Anmelden zum Antworten