Wie verwenden Sie printf() in mehrere threads

POSIX-Spezifikationen

POSIX-Spezifikation umfasst die folgenden Funktionen:

• getc_unlocked()
• getchar_unlocked()
• putc_unlocked()
• putchar_unlock()

Versionen der Funktionen getc(), getchar(), putc(), und putchar() bzw. benannt getc_unlocked(), getchar_unlocked(), putc_unlocked(), und putchar_unlocked() erbracht werden, die funktional äquivalent zu den ursprünglichen Versionen, mit der Ausnahme, dass Sie nicht erforderlich sind, umgesetzt werden, eine vollständig thread-sichere Weise. Sie sind thread-sicher, wenn verwendet, in einen Bereich, geschützt durch flockfile() (oder ftrylockfile()) und funlockfile(). Diese Funktionen können sicher verwendet werden, in einem multi-threaded Programm, wenn und nur wenn Sie aufgerufen werden, während das aufrufende thread besitzt die (FILE *) Objekt, wie es der Fall nach einem erfolgreichen Aufruf der flockfile() oder ftrylockfile() Funktionen.

Die Spezifikation für diese Funktionen zu erwähnen:

• flockfile()
• ftrylockfile()
• funlockfile()

Die Spezifikation für flockfile() et al schließt die Decke Anforderung:

Alle Funktionen, die ein Verweis (FILE *) Gegenstände, ausgenommen jene, die mit Namen, endend in _unlocked, Verhalten, als ob Sie Sie nutzen flockfile() und funlockfile() intern zum Erwerb des Eigentums an diesen (FILE *) Objekte.

Dieser ersetzt den vorgeschlagenen code in früheren Ausgaben dieser Antwort. Der POSIX-standard legt auch fest:

[ *lockfile() ] Funktionen Verhalten, als wenn es ein Schloss-Zählung, die mit jedem (FILE *) Objekt. Diese Anzahl wird implizit mit null initialisiert, wenn die ( FILE * ) - Objekt erstellt wird. Die (FILE *) Objekt ist freigegeben, wenn die Zählung null ist. Wenn die Zählung positiv ist, einem einzigen thread besitzt die (FILE *) Objekt. Wenn die flockfile() Funktion wird aufgerufen, wenn der Zähler gleich null ist oder wenn der Zähler positiv ist und der Anrufer besitzt die (FILE *- Objekt), die Anzahl soll erhöht werden. Andernfalls wird der aufrufende thread wird angehalten, wartet der Graf zurück auf null. Jeder Aufruf funlockfile() ist verringern Sie die Anzahl. Dies ermöglicht die passende Aufrufe flockfile() (oder erfolgreiche Gespräche zu ftrylockfile()) und funlockfile() geschachtelt werden.

Dort sind auch die Spezifikationen für die Zeichen-I/O-Funktionen:

• getc()
• getchar()
• putc()
• putchar()
• fgetc()
• fputc()

Die formatierte Ausgabe-Funktionen werden hier dokumentiert:

• printf()

Eine zentrale Bestimmung in den printf() Spezifikation:

Zeichen generiert fprintf() und printf() gedruckt, als wenn fputc() berufen worden war.

Beachten Sie die Verwendung von 'als ob'. Jedoch, jeder der printf() Funktionen ist erforderlich, um die sperren so, dass der Zugang zu einem Strom gesteuert wird, die in einer multi-threaded-Anwendung. Nur ein thread zu einem Zeitpunkt kann mit einer bestimmten Datei-stream. Wenn die Operationen sind user-level-Aufrufe fputc(), dann können andere threads einstreuen, die Ausgabe. Wenn die Operationen sind user-level-Aufrufe wie printf(), das ganze dann anrufen und alle den Zugriff auf die stream-Datei ist tatsächlich geschützt, so dass nur ein thread ist, es zu benutzen, bis der Anruf zu printf() gibt.

In den Abschnitt der System-Schnittstellen: Allgemeine Informationen Abschnitt POSIX zum Thema Threads, es sagt:

2.9.1 Thread-Sicherheit

Alle Funktionen definiert durch das Volumen von POSIX.1-2008 sind thread-sicher ist, außer dass die folgenden functions1 müssen nicht thread-sicher.

...eine Liste von Funktionen, die müssen nicht thread-sicher...

... Die getc_unlocked(), getchar_unlocked(), putc_unlocked(), und putchar_unlocked() Funktionen müssen nicht thread-sicher, wenn die Aufruf-thread besitzt die (FILE *) zugegriffene Objekt durch den Aufruf, wie es der Fall nach einem erfolgreichen Aufruf der flockfile() oder ftrylockfile() Funktionen.

Implementierungen stellen interne Synchronisation nötig sind, um diese Anforderung erfüllen.

Die Liste der ausgenommenen Funktionen nicht enthalten fputc oder putc oder putchar (oder printf() et al.).

Interpretation

^{Umgeschrieben 2017-07-26.}

1. Charakter-level-Ausgang auf einen stream ist thread-sicher, wenn mit der "unlocked" - Funktionen, ohne die erste Verriegelung der Datei.
2. Higher-level-Funktionen wie printf() konzeptionell nennen flockfile() am Anfang ein funlockfile() am Ende, was bedeutet, dass die POSIX-definierten stream-Ausgabe-Funktionen werden auch thread-safe pro Anruf.
3. Wenn Sie möchten, gruppieren Sie Operationen auf einem stream-Datei für einen einzelnen thread, man kann so tun, indem Sie explizit durch Aufrufe flockfile() und funlockfile() auf den entsprechenden stream (ohne sich mit der Verwendung des Systems die *lockfile() Funktionen.

Dies bedeutet, es gibt keine Notwendigkeit zu schaffen, Mutexe oder gleichwertige Mechanismen für sich selbst; die Umsetzung stellt die Funktionen ermöglichen Ihnen die Steuerung der Zugang zu printf() et al in einer multi-threaded-Anwendung.

^{...Code vom vorherigen Antwort entfernt, da nicht mehr relevant...}

InformationsquelleAutor Jonathan Leffler

Für linux ,hier ist der code für u in c:3 threads ,die Ausführung auf unterschiedlichen Kernen drucken Hallo Welt ,nicht in Konflikt mit einander courtisey der Sperre .

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <syscall.h>
#include <sys/types.h>

void * printA ( void *);
void * printB ( void *);
void * printC ( void *);

pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;


int main(int argc,  char *argv[]) {
   int error;
   pthread_t tid1, tid2,tid3;

    if ( error = pthread_create (&tid1, NULL, printA, NULL ))
        {
        fprintf (stderr, "Failed to create first thread: %s\n",strerror(error));
        return 1;
    }
    if ( error = pthread_create (&tid2, NULL, printB, NULL ))
        {
        fprintf (stderr, "Failed to create second thread: %s\n",strerror(error));
        return 1;
    }
    if ( error = pthread_create (&tid3, NULL, printC, NULL ))
        {
        fprintf (stderr, "Failed to create second thread: %s\n",strerror(error));
        return 1;
    }

    if (error = pthread_join(tid1, NULL))
        {
        fprintf (stderr, "Failed to join first thread: %s\n",strerror(error));
        return 1;
    }
    if (error = pthread_join(tid2, NULL))
        {
        fprintf (stderr, "Failed to join second thread: %s\n",strerror(error));
        return 1;
    }

    if (error = pthread_join(tid3, NULL))
        {
        fprintf (stderr, "Failed to join second thread: %s\n",strerror(error));
        return 1;
    }
    return 0;
}

void * printA ( void *arg )
{
      if ( error = pthread_mutex_lock( &mylock ))
      {
    fprintf (stderr, "Failed to acquire lock in printA: %s\n",strerror(error));
    return NULL;
      }
   printf("Hello world\n");

      if ( error = pthread_mutex_unlock( &mylock ))
      {
    fprintf (stderr, "Failed to release lock in printA: %s\n",strerror(error));
    return NULL;
      }
   }

void * printB ( void *arg )
{
   int error;
      if ( error = pthread_mutex_lock( &mylock ))
      {
    fprintf (stderr, "Failed to acquire lock in printB: %s\n",strerror(error));
    return NULL;
      }


   printf("Hello world\n");

      if ( error = pthread_mutex_unlock( &mylock ))
      {
    fprintf (stderr, "Failed to release lock in printA: %s\n",strerror(error));
    return NULL;
      }
   }


void * printC ( void *arg )
{
   int error;
      if ( error = pthread_mutex_lock( &mylock ))
      {
    fprintf (stderr, "Failed to acquire lock in printB: %s\n",strerror(error));
    return NULL;
      }


   printf("Hello world\n");

      if ( error = pthread_mutex_unlock( &mylock ))
      {
    fprintf (stderr, "Failed to release lock in printA: %s\n",strerror(error));
    return NULL;
      }
   }

InformationsquelleAutor Nasir Ul Islam Butt