La versione più recente è stata modificata il 2007-05-23 18:17:47 da MarKuS
Aggiunzioni:
Tentare di distruggere un mutex bloccato non é una buona idea!
Omissioni:
Tentare di distruggere un mutex bloccato non é una buona idea!
Modificato il 2007-05-23 17:59:43 da MarKuS
Aggiunzioni:
Questa pagina fa il paio con quella dedicata alle api di Window$. Le informazioni contenute in essa provengono in gran parte dalle manpages presenti di default in ogni distribuzione GNU/Linux decente e sono, per quanto possibile, state verificate con qualche esperimento sulle mie macchine. Per ulteriori approfondimenti potete consultare le manpages.
questo non sia già terminato. Se non vi sono errori e viene specificato un puntatore non-NULL, viene restituito attraverso questo riferimento il valore passato a pthread_exit() dal thread terminante. Evitate chiamate multiple a pthread_join() riferite allo stesso thread.
Tentare di distruggere un mutex bloccato non é una buona idea!
blocca il mutex (bloccante)
I mutex vanno acquisiti utilizzando pthread_mutex_lock(). Se il mutex é già bloccato, il thread chiamante si bloccherà fino a quando il mutex diviene nuovamente il mutex diviene nuovamente disponibile. Questa operazione ritornerà con l'oggetto mutex in stato bloccato, posseduto dal thread chiamante.
blocca il mutex (non bloccante)
Le funzioni pthread_mutex_lock() e pthread_mutex_trylock() sono equivalenti con l'eccezione che se il mutex specificato è già bloccato, pthread_mutex_lock() blocca il thread chiamante e attende che il mutex divenga disponibile, mentre pthread_mutex_trylock() ritorna immediatamente con un valore non nullo (errore).
La funzione pthread_mutex_unlock() rilascia il mutex specificato dal parametro mutex. Se vi sono thread bloccati in attesa di acquisire il mutex, la policy di schedulazione determinerà quale thread dovra acquisire il mutex.
Omissioni:
Questa pagina fa il paio con quella dedicata alle api di Window$. Le informazioni contenute in essa provengono in gran parte dalle manpages presenti di default in ogni distribuzione GNU/Linux decente e sono, per quanto possibile, state verificate con qualche esperimento sulle mie macchine.
questo non sia già terminato. Se non vi sono errori e viene specificato un puntatore non-NULL, viene restituito attraverso questo riferimento il valore passato a pthread_exit() dal thread terminante. E' bene evitare chiamate multiple a pthread_join() riferite allo stesso thread.
Tentare di distruggere un mutex bloccato non é una buona idea!
Utilizzo dei mutex
I mutex vanno acquisiti utilizzando pthread_mutex_lock(). Se il mutex é già bloccato, il thread chiamante si bloccherà fino a quando il mutex diviene nuovamente il mutex diviene nuovamente disponibile. Questa operazione ritornerà con l'oggetto mutex in stato bloccato, posseduto dal thread chiamante.
Se il tipo del mutex è PTHREAD_MUTEX_NORMAL, non viene effettuata alcuna prevenzione dei deadlock. Il tentativo di ribloccare un mutex già bloccato causa un deadlock. Se un thread prova a sbloccare un mutex che non era stato bloccato in precedenza, ne risulta un comportamento indefinito. (ergo, non lo fate!)
blocca il mutex - non bloccante)
blocca il mutex
Modificato il 2007-05-23 17:43:02 da MarKuS
Aggiunzioni:
Utilizzo dei mutex
I mutex vanno acquisiti utilizzando pthread_mutex_lock(). Se il mutex é già bloccato, il thread chiamante si bloccherà fino a quando il mutex diviene nuovamente il mutex diviene nuovamente disponibile. Questa operazione ritornerà con l'oggetto mutex in stato bloccato, posseduto dal thread chiamante.
Se il tipo del mutex è PTHREAD_MUTEX_NORMAL, non viene effettuata alcuna prevenzione dei deadlock. Il tentativo di ribloccare un mutex già bloccato causa un deadlock. Se un thread prova a sbloccare un mutex che non era stato bloccato in precedenza, ne risulta un comportamento indefinito. (ergo, non lo fate!)
blocca il mutex - non bloccante)
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
Omissioni:
blocca il mutex (non bloccante))
Modificato il 2007-05-23 11:30:20 da MarKuS
Aggiunzioni:
La funzione pthread_mutex_init() inizializza il mutex referenziato dal parametro mutex con gli attributi specificati dal parametro attr. If attr é NULL, vengono utilizzati gli attributi di default. In assenza di errori il mutex viene inizializzato ed impostato a sbloccato.
distrugge il mutex
int pthread_mutex_destroy(pthread_mutex_t *mutex);
L'oggetto mutex viene deinizializzato e distrutto, un mutex distrutto può essere reinizializzato. Qualsiasi altra operazione non é definita.
Tentare di distruggere un mutex bloccato non é una buona idea!
Omissioni:
dealloca tutte le risorse allocate per gestire il mutex specificato
Modificato il 2007-05-23 11:15:40 da MarKuS
\Nessuna differenza.
Modificato il 2007-05-23 11:14:50 da MarKuS
Aggiunzioni:
un semplice esempio che non fa nulla di particolarmente utile...
/* Una piccola dimostrazione sulla creazione, sincronizzazione e terminazione
dei thread utilizzando la libreria nix pthread. Con l'aggiunta di un mutex
#include <unistd.h>
/* globale */
pthread_mutex_t mutex;
puts ("Acquisizione del mutex...");
pthread_mutex_lock( &mutex );
/* non é necessaria, ma logicamente corretta */
pthread_mutex_unlock( &mutex );
/* inizializza il mutex per la sincronizazione dei thread. */
puts("Inizializza e acquisisce il mutex");
pthread_mutex_init ( &mutex, NULL );
pthread_mutex_lock ( &mutex );
/* fa qualcosa per 3 sec. poi rilascia il mutex */
sleep( 3 );
pthread_mutex_unlock( &mutex );
Modificato il 2007-05-23 10:47:34 da MarKuS
Aggiunzioni:
La funzione pthread_create() crea all'interno del processo un nuovo thread, con gli attributi specificati da attr. Se attr é NULL, vengono utilizzati gli attributi di default. Se non si verificano errori l'ID del thread appena creato viene salvato nella locazione indirizzata dal parametro thread. Il thread viene creato mandando in esecuzione la funzione start_routine con l'unico parametro arg. Se la funzione start_routing ritorna l'effetto sarà analogo a quello di una chiamata esplicita a pthread_exit().
Modificato il 2007-05-23 10:25:32 da MarKuS
Aggiunzioni:
void **value_ptr
dei thread utilizzando la libreria nix pthread.
*/
#include <stdio.h>
void my_func(void)
int i;
int somma=0;
int prodotto=1;
for (i=1;i<=10;i) {
somma += i;
prodotto *= i;
}
printf("somma = %d\nprodotto = %d\n", somma, prodotto );
/* la chiamata a pthread_exit() é _implicita_ */
puts("Uscita dal thread figlio...");
main()
pthread_t thread;
/* crea il nuovo thread, destinato ad eseguire la funzione my_func */
puts("Creazione del thread...");
if (!pthread_create( &thread, NULL, my_func, NULL )) {
/* pthread_create restituisce 0 se non ci sono stati errori nella creazione
del thread
*/
/* pthread_join attende la terminazione del thread figlio. */
puts("Attesa del thread...");
pthread_join( thread, NULL );
}
puts ("Fine :-)");
return 0;
Omissioni:
void value_ptr
Modificato il 2007-05-23 10:14:14 da MarKuS
Aggiunzioni:
pthread_t thread
la struttura che contiene le informazioni relative al thread.
void value_ptr
puntatore utilizzato per la restituzione del valore di ritorno del thread.
Questa funzione sospenderà l'esecuzione del thread chiamante fino a quando il thread specificato termina, a meno che
questo non sia già terminato. Se non vi sono errori e viene specificato un puntatore non-NULL, viene restituito attraverso questo riferimento il valore passato a pthread_exit() dal thread terminante. E' bene evitare chiamate multiple a pthread_join() riferite allo stesso thread.
una piccola demo
Modificato il 2007-05-23 09:50:20 da MarKuS
Aggiunzioni:
[n4rc0s@maggie so]$ gcc -lpthread prova_thread.c
Questa funzione viene chiamata implicitamente al termine dell'esecuzione della funzione start_routine specificata in fase della creazione del thread figlio. In generale quindi non è necessario utilizzarla, se non nei casi in cui è necessario anticipare l'interruzione dell'esecuzione del thread.
Omissioni:
n4rc0s@barney/~$ gcc -lpthread prova_thread.c
Modificato il 2007-05-22 20:08:35 da MarKuS
Aggiunzioni:
Gestione dei Mutex
Le funzioni dedicate alla gestione dei mutex sono anch'esse all'interno della libreria pthread.
pthread_mutex_init
inizializza il mutex specificato
pthread_mutex_destroy
dealloca tutte le risorse allocate per gestire il mutex specificato
pthread_mutex_trylock
blocca il mutex (non bloccante))
pthread_mutex_lock
blocca il mutex
pthread_mutex_unlock
rilascia il mutex
Modificato il 2007-05-22 20:00:42 da MarKuS
Aggiunzioni:
file: prova_thread.c
#include <pthread.h>
int main()
{
...
}
Omissioni:
CreateThread
Crea un nuovo thread.
Restituisce un HANDLE al nuovo thread. Conservatelo con cura: tutte le chiamate di sistema che manipolano i thread necessitano di questo valore. In ogni funzione troverete sempre un parametro HANDLE hThread, che vuol dire sempre la stessa cosa: su quale thread deve operare la funzione che state invocando.
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
lpThreadAttributes
puntatore a una struttura di descrittori di sicurezza. Fondamentamentalmente a noi non serve. (NULL)
dwStackSize
dimensione iniziale dello stack. Usate 0 per il default.
lpstartAddress
la funzione che deve girare nel Thread separato. Questa va dichiarata "DWORD my_func( LPVOID param )", param riceve il valore lpParameter (vedi sotto)
lpParameter
puntatore ai dati passati all funzione nel nuovo thread
dwCreationFlag
FLAG di creazione del thread
+ SUSPENDED, il thread non si avvia automaticamente dopo la creazione (vedi ResumeThread, SuspendThread)
0 default
lpThreadId
Sostanzialmente inutile (NULL)
(c)/* (NdM - Nota di MarKuS)
se create più di un thread, ad es. in un ciclo, ricordatevi che
non potete
fare affidamento sull'ordine di esecuzione dei diversi thread. */
HANDLE hThreads[N_THREADS];
for (i=0;i<N_THREADS; i
) {
hThreads[i] = CreateThread( NULL, 0, my_func, &i, 0, NULL ); /* NO! */
}
/* i verrà modificato mille volte prima che il primo dei thread creati si svegli ! */
Modificato il 2007-05-22 19:58:32 da MarKuS
Aggiunzioni:
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
pthread_exit(void *value_ptr);
int pthread_join(pthread_t thread, void **value_ptr);
Omissioni:
termina il thread corrente sino al termine del thread specificato
Modificato il 2007-05-22 19:17:24 da MarKuS
Aggiunzioni:
Piccola Guida alle chiamate di sistema **nix
Questa pagina fa il paio con quella dedicata alle api di Window$. Le informazioni contenute in essa provengono in gran parte dalle manpages presenti di default in ogni distribuzione GNU/Linux decente e sono, per quanto possibile, state verificate con qualche esperimento sulle mie macchine.
La libreria pthread
Un thread è un flusso di esecuzione all'interno di un processo. Ogni thread contiene una
quantità minima di informazioni di stato; normalmente solo lo stato della CPU ed una maschera
per i segnali. Tutte le altre informazioni sullo stato del processo (quali ad esempio la memoria, i descrittori
dei file) sono condivise tra tutti i thread all'interno dello stesso processo.
NB: Per utilizzare il supporto pthread occorre richiedere al linker l'inclusione della libreria. Quindi ad es.
n4rc0s@barney/~$ gcc -lpthread prova_thread.c
pthread_create
crea un nuovo thread
pthread_exit
termina il thread corrente
pthread_join
termina il thread corrente sino al termine del thread specificato
attende la terminazione di un thread
Omissioni:
Piccola Guida alle chiamate di sistema Linux
Questa pagina fa il paio con quella dedicata alle api di Window$. Le informazioni contenute in essa provengono in gran parte dalle manpages linux, presenti di default in ogni distribuzione decente e sono, per quanto possibile, state verificate con qualche esperimento sulle mie macchine.
Modificato il 2007-05-22 18:56:47 da MarKuS
Aggiunzioni:
Piccola Guida alle chiamate di sistema Linux
(Quello che serve per il corso)
Questa pagina fa il paio con quella dedicata alle api di Window$. Le informazioni contenute in essa provengono in gran parte dalle manpages linux, presenti di default in ogni distribuzione decente e sono, per quanto possibile, state verificate con qualche esperimento sulle mie macchine.
Gestione dei processi
...
Gestione dei Thread (si legge thréd, con la "e", non thrid con la "i")
CreateThread
Crea un nuovo thread.
Restituisce un HANDLE al nuovo thread. Conservatelo con cura: tutte le chiamate di sistema che manipolano i thread necessitano di questo valore. In ogni funzione troverete sempre un parametro HANDLE hThread, che vuol dire sempre la stessa cosa: su quale thread deve operare la funzione che state invocando.
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
lpThreadAttributes
puntatore a una struttura di descrittori di sicurezza. Fondamentamentalmente a noi non serve. (NULL)
dwStackSize
dimensione iniziale dello stack. Usate 0 per il default.
lpstartAddress
la funzione che deve girare nel Thread separato. Questa va dichiarata "DWORD my_func( LPVOID param )", param riceve il valore lpParameter (vedi sotto)
lpParameter
puntatore ai dati passati all funzione nel nuovo thread
dwCreationFlag
FLAG di creazione del thread
+ SUSPENDED, il thread non si avvia automaticamente dopo la creazione (vedi
ResumeThread,
SuspendThread)
0 default
lpThreadId
Sostanzialmente inutile (NULL)
/* (NdM - Nota di MarKuS)
se create più di un thread, ad es. in un ciclo, ricordatevi che __non__ potete
fare affidamento sull'ordine di esecuzione dei diversi thread. */
HANDLE hThreads[N_THREADS];
for (i=0;i<N_THREADS; i++) {
hThreads[i] = CreateThread( NULL, 0, my_func, &i, 0, NULL ); /* NO! */
}
/* i verrà modificato mille volte prima che il primo dei thread creati si svegli ! */
La versione più vecchia di questa pagina è stata modificata il 2007-05-22 18:42:30 da MarKuS []
Vista della pagina:
coming soon ;-)
