Applicazione che fornisce chiavi univoche a più thread

Question

Applicazione che fornisce chiavi univoche a più thread

#1 da (1 voti)

0

Grazie a tutti per il vostro aiuto prima. Quindi, questo è quello che ho inventato finora,

i requisiti sono, l'applicazione ha due o più thread e ogni thread richiede un ID sessione / transazione univoco. è il thread considerato considerato sicuro?

il thread 1 si registrerà con get_id inviando il suo pid il thread 2 farà lo stesso

then thread 1 & 2 chiamerà la funzione per ottenere un ID univoco

function get_id(bool choice/*register thread or get id*/, pid_t pid)
{

static int pid[15][1]={0};//not sure if this work, anyway considor any it's been set to 0 by any other way than this
static int total_threads = 0; 
static int i = 0;
int x=0,y=0;

    if (choice) // thread registeration part 
    {
        for(x=0;x<15;x++)
        {
            if (pid[x][0]==0);
            {
            pid[x][0] = (int) pid;
            pid[x][1] = (x & pidx[x][1]) << 24;//initiate counter for this PID by shifting x to the 25th bit, it could be any other bit, it's just to set a range.
            //so the range will be between 0x0000000 and 0x0ffffff, the second one              will be 0x1000000 and 0x1ffffff, 
            break;
            }
        total_threads++;
        } 
    }

//search if pid exist or not, if yes return transaction id 
        for(x=0;x<15;x++)
        {
            if (pid[x][0]==pid);
            {
            pid[x][1]++;//put some test here to reset the number to 0 if it reaches 0x0ffffff
            return pid[x][1];
            break;
            }

        } 

}

c multithreading

posta poly 14.04.2012 - 22:05

fonte

1 risposta

Leggi altre domande sui tag c multithreading

Dimensione del metodo in un linguaggio OOP, ad esempio - in Java [duplicato] mysql design della tabella di ricerca testo completo

score 1 · Answer 1

Alcuni suggerimenti:

Threads vs. Processi

Nella tua descrizione, menzioni i thread e hai una variabile total_threads. Tuttavia, nel codice si usa un tipo pid_t e si nomina un pid di tabella. Per favore, sii preciso nella tua lingua.
Questo codice può essere eseguito solo in un processo, quindi sospetto che tu abbia a che fare principalmente con i thread.

C Training

Potresti non avere familiarità con alcune delle convenzioni della programmazione in C
Per fornire il massimo aiuto possibile, probabilmente dovremo vedere i file di inclusione che usi, in particolare quello che definisce pid_t. È anche utile se vediamo il codice che chiama la tua funzione.
C'è una variabile pidx che non è definita e viene usata come pidx [x] [1]. Mi aspetto che sia un errore di battitura.
Nel tuo codice, per accedere a pid [x] [0] e pid [x] [1], dovrai dichiarare static int pid [15] [2]. static int pid [15] [1] è un array di quindici array di un elemento ciascuno.
Rivedi operatori logici bit a bit. Hai almeno una dichiarazione che probabilmente non ti darà quello che vuoi.
Le colonne dell'array non sono omogenee. La prima colonna sembra essere confrontata con i valori pid_t e sospetto che la seconda colonna possa trarre vantaggio dalla definizione e dall'uso delle variabili sessionID_t. Si potrebbe fare di questa tabella una serie di strutture con due elementi di tipi pid_t e sessionID_t.
pid non è un nome molto descrittivo, e penso che tu abbia menzionato gli ID di thread nella tua descrizione. Forse la tabella dovrebbe essere denominata threadID_to_sessionID_table.
Dovresti leggere la descrizione della dichiarazione di reso. Scoprirai che non avresti mai bisogno di una pausa; nel contesto in cui è usato sopra.
Nel caso in cui nessun pid sia abbinato, cosa viene restituito? È necessario restituire un valore per qualsiasi percorso attraverso questa funzione, forse zero se si tratta di un valore di dati non valido.
Suggerisco di spostare la tabella e la variabile total_threads all'esterno della funzione e dichiararla statica a livello di modulo. Ciò ti consentirebbe di estenderne l'utilizzo quando identificherai più funzioni che necessitano di tali dati.
Uno dei tuoi commenti sembra indicare un problema che potrebbe essere causato dall'uso di int anziché di unsigned int.
Come punto dello stile C, se selezioni una dimensione di array di 15 e 15 nel tuo programma, stai usando una costante manifest. Ci sono due problemi con questo. Innanzitutto, se decidi che il tuo array ha bisogno di 16, devi sostituire tutti i 15 associati all'utilizzo dell'array con 16. Secondo, (e questo è molto peggio), se trovi un altro 15 che è effettivamente usato per qualcos'altro e rendilo 16, puoi creare un crash. La soluzione a questo problema è creare una costante definita con un'istruzione come:

#define SESSION_ID_TABLE_MAX 15

Algoritmo

Questa funzione sembra fare due cose. Chiamato get_id (true, my_pid) assegna un id di sessione e lo memorizza nella tabella. Chiamato get_id (false, my_pid) cerca semplicemente l'id della sessione. Usare una bandiera o una variabile per governare una funzione per eseguire il lavoro di due funzioni separate è considerata una cattiva pratica. Ti suggerisco di creare due funzioni allocate_session_id (pid) e find_session_id (pid).
Sono preoccupato per il modo in cui crei gli ID di sessione dal pid. Se il pid è maggiore di otto bit e l'int è di 32 bit, sei nei guai. L'uso di un numero intero a 32 bit con segno rende le cose ancora più pericolose.
Non c'è nulla di sicuro in questo codice. Ogni volta che si utilizza una sequenza con un confronto seguito da un passaggio che modifica la tabella, è necessaria una regione critica. Altrimenti, un altro thread nel sistema può calpestarlo a volontà.
In che modo è inteso utilizzare Total_threads? Suggerirei che l'indice del ciclo nel primo ciclo for potrebbe essere total_threads. Se arrivi alla fine del ciclo senza trovare una corrispondenza, aggiungi l'id del thread e l'id della sessione e incrementa l'id del thread.
Dovresti utilizzare alcuni controlli dell'intervallo di array. Se la matrice è piena, è necessario saltare il tentativo di allocare un nuovo ID di sessione e restituire qualcosa per indicare che l'allocazione non è riuscita. Questo è un posto in cui avere funzioni separate aiuterà.
Se si ha una trasformazione del PID nell'ID di sessione, forse questo potrebbe essere incapsulato nella propria funzione per consentire la facilità di analisi, manutenzione e magari test delle unità.
Il metodo utilizzato per creare gli ID di sessione sembra non corretto.