timer con thread in coda

Innanzitutto, la struttura che si desidera in questo caso è probabilmente una coda di priorità. Utilizzerai il tempo di scadenza di ciascun articolo per determinarne la priorità in coda.

In questo caso, il thread del consumatore attende che si verifichi una di queste due cose: l'ora in cui il primo elemento della coda deve essere scaduto, oppure un elemento appena inserito finisce all'inizio della coda.

Se ho capito bene, hai bisogno che ogni elemento della coda scada dopo un certo periodo di tempo, ma hai ancora bisogno di oggetti che non sono scaduti per essere consumati osservando la regola FIFO.

In questo caso, non è necessario necessariamente un timer o un terzo thread; lascia semplicemente gli elementi scaduti in coda e, se necessario, controlla se l'elemento che ottieni è scaduto o meno (controlla l'ora corrente e il tempo di attesa + il tuo timeout). In caso contrario, spingerlo al consumatore, se lo ha, smaltirlo.

Nel caso in cui sia necessario disporre delle risorse quando gli articoli scadono o per generare eventi per gli osservatori, è possibile creare una struttura dati esterna che faccia esattamente questo (il raccoglitore con una coda di priorità per scadenza, come indicato da Jerry Coffin) , ma non è necessario collegarlo in alcun modo diretto al produttore-consumatore (a parte la sincronizzazione per essere sicuro di non consumare qualcosa che viene smaltito).

Se il tempo di utilizzo è il momento in cui è entrato nella coda, non è necessaria alcuna coda di priorità, solo un semplice FIFO. Il thread consumatore legge gli articoli fino a quando ne trova uno che non è obsoleto, quindi legge anche quello.

Pseudo codice:

typedef struct
{
  obj_t  obj;
  time_t time;
} queue_item_t;


result_t fifo_add (const obj_t* obj)
{
  queue_item_t qi;

  qi.obj  = *obj;
  qi.time = time(NULL);

  return add_to_fifo(&qi);
}


result_t fifo_remove (obj_t* returned_obj)
{
  queue_item_t qi;
  bool item_expired;

  do
  {
    if(remove_from_fifo(&qi) == EMPTY_QUEUE)
    {
      return EMPTY_QUEUE;
    }
    item_expired = expired(&qi);
  } while(item_expired);

  if(item_expired) // all items removed, all had expired
  {
    return EMPTY_QUEUE;
  }

  *returned_obj = qi.obj;
  return OK;
}

inline bool expired (const queue_item_t* ptr_qi)
{
  return ptr_qi->time < time(NULL) - TIMEOUT_CONSTANT;
}

Solo pseudo, niente compilato o testato. Puoi inserire le guardie mutex all'interno delle funzioni di aggiunta e rimozione per prestazioni ottimali.