POSIX Threads

Da Wikipedia, l'enciclopedia libera.
Jump to navigation Jump to search

I POSIX Threads, solitamente denominati pthreads, sono un modello di esecuzione che esiste indipendentemente da un linguaggio di programmazione, nonché un modello di esecuzione parallelo. Consente a un programma di controllare più flussi di lavoro diversi che si sovrappongono nel tempo. Ogni flusso di lavoro viene definito thread e la creazione e il controllo di questi flussi si ottiene effettuando chiamate all'API dei thread POSIX. POSIX Threads è un'API definita dalle estensioni standard di POSIX.1c, Thread (IEEE Std 1003.1c-1995).

Le implementazioni delle API sono disponibili su molti sistemi operativi simili a Unix e conformi allo standard POSIX, come FreeBSD, NetBSD, OpenBSD, Linux, Mac OS X, Android e Solaris. In genere sono raggruppati in una libreria denominata libpthread. Esistono anche implementazioni DR-DOS e Microsoft Windows: all'interno del sottosistema SFU/SUA che fornisce un'implementazione nativa di un certo numero di API POSIX e anche all'interno di pacchetti di terze parti come pthreads-w32, che implementa pthreads sopra le API Windows esistente.

Contenuti[modifica | modifica wikitesto]

pthreads definisce un insieme di tipi, funzioni e costanti in linguaggio C. È implementato con un'intestazione pthread.h e una libreria di thread.

Esistono circa 100 procedure di thread, tutte con prefisso pthread_ e possono essere classificate in quattro gruppi:

  • Gestione dei thread: creazione, unione, ecc.
  • mutex
  • Variabili di condizione
  • Sincronizzazione tra thread utilizzando blocchi di lettura/scrittura e barriere

L'API POSIX dei semafori funziona con i thread POSIX ma non fa parte dei thread standard, essendo stata definita nello standard POSIX.1b - estensioni in tempo reale (IEEE Std 1003.1b-1993). Di conseguenza, le procedure del semaforo sono precedute da sem_ invece di pthread_.

Esempio[modifica | modifica wikitesto]

Un esempio che illustra l'uso di pthread in linguaggio C:

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<pthread.h>
#include<unistd.h>

#define NUM_THREADS 5

void *perform_work(void *arguments){
  int index=*((int *)arguments);
  int sleep_time=1+rand()%NUM_THREADS;
  printf("THREAD %d: Started.\n",index+1);
  printf("THREAD %d: Will be sleeping for %d seconds.\n",index+1,sleep_time);
  sleep(sleep_time);
  printf("THREAD %d: Ended.\n",index+1);
  return NULL;
}

int main(){
  pthread_t threads[NUM_THREADS];
  int thread_args[NUM_THREADS];
  short i;
  int result_code;
  
  //create all threads one by one
  for(i=0;i<NUM_THREADS;i++){
    printf("IN MAIN: Creating thread %d.\n",i+1);
    thread_args[i]=i;
    result_code=pthread_create(&threads[i],NULL,perform_work,&thread_args[i]);
    assert(!result_code);
  }

  printf("IN MAIN: All threads are created.\n");

  //wait for each thread to complete
  for(i=0;i<NUM_THREADS;i++){
    result_code=pthread_join(threads[i],NULL);
    assert(!result_code);
    printf("IN MAIN: Thread %d has ended.\n",i+1);
  }

  printf("MAIN program has ended.\n");
  return 0;
}

Questo programma crea cinque thread, ognuno dei quali esegue la funzione perform_work che stampa il numero univoco del thread sullo standard output. Se un programmatore desidera che i thread comunichino tra loro, ciò richiederebbe la definizione di una variabile al di fuori dell'ambito di ciascuna funzione, rendendola una variabile globale. Questo programma può essere compilato usando il compilatore gcc con il seguente comando:

gcc pthreads_demo.c -lpthread -o pthreads_demo

POSIX Threads per Windows[modifica | modifica wikitesto]

Windows non supporta lo standard pthreads in modo nativo, pertanto il progetto Pthreads-w32 cerca di fornire un'implementazione wrapper portatile e open source. Può anche essere usato per portare il software Unix (che utilizza pthreads) con poca o nessuna modifica alla piattaforma Windows. Con alcune patch aggiuntive l'ultima versione 2.8.0 è compatibile con i sistemi Windows a 64 bit. Si dice che anche la versione 2.9.0 sia compatibile a 64 bit.

Il progetto mingw-w64 contiene anche un'implementazione di wrapper di pthreads chiamata winpthreads, che tenta di utilizzare più chiamate di sistema native rispetto al progetto Pthreads-w32.

Il sottosistema di ambiente Interix disponibile in Windows Services for UNIX/Subsystem for UNIX-based Application fornisce una porta nativa dell'API pthreads, ossia non mappata sull'API Win32/Win64 ma costruita direttamente sull'interfaccia syscall del sistema operativo.

Note[modifica | modifica wikitesto]


Bibliografia[modifica | modifica wikitesto]

  • David R. Butenhof (1997). Programming with POSIX Threads. Addison-Wesley. ISBN 978-0-201-63392-4.
  • Bradford Nichols; Dick Buttlar; Jacqueline Proulx Farell (September 1996). Pthreads Programming. O'Reilly & Associates. ISBN 978-1-56592-115-3.
  • Charles J. Northrup (1996-01-25). Programming with UNIX Threads. John Wiley & Sons. ISBN 978-0-471-13751-1.
  • Kay A. Robbins & Steven Robbins (2003). UNIX Systems Programming. Prentice-Hall. ISBN 978-0-13-042411-2.

Voci correlate[modifica | modifica wikitesto]

  • Runtime system
  • OpenMP
  • Cilk/Cilk Plus
  • Threading Building Blocks (TBB)
  • Native POSIX Thread Library (NPTL)
  • DCEThreads
  • clone (Linux system call)
  • Spurious wakeup
  • Thread-local storage
  • GNU Portable Threads
  • FSU Pthreads
  • Grand Central Dispatch (la libreria thread per Apple)
  • Beginthread (una subroutine in Windows per creare un nuovo thread e uno Unix thread)
  • State Threads, un approccio event driven al threading

Collegamenti esterni[modifica | modifica wikitesto]

  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica