Question

How would one go about creating a queue that can hold an array, more over an array with variable amounts of rows.

char data[n][2][50];
//Could be any non 0 n e.g:
n=1; data = {{"status","ok}};
// or
n=3; {{"lat", "180.00"},{"long","90.123"},{"status","ok}};
// and so on

n to be added to the queue. Or is there even a better solution than what I’m asking? A queue is easy enough to write (or find re-usable examples of) for single data items but I’m not sure what method I would use for the above. Maybe a struct? That would solve for array and n…but would it solve for variable array?

More broadly the problem I’m trying to solved is this.
I need to communicate with a web server using POST. I have the code for this already written however I don’t want to keep the main thread busy every time this task needs doing, especially since I need to make other checks such as is the connection up, if it isn’t I need to back off and wait or try and bring it back online.

My idea was to have a single separate dedicated to this task. I figured creating a queue would be the best way for the main thread to let the child thread know what to do.

The data will be a variable number of string pairs. like:

Main

//Currently does
  char data[MAX_MESSAGES_PER_POST][2][50];
  ...
  assembles array
  sendFunction(ptrToArray, n);
  resumes execution with large and un predicatable delay

//Hopefully will do
  ...
  queue(what needs doing)
  carry on executing with (almost) no delay

Child

while(0)
{
  if(allOtherConditionsMet())  //Device online and so forth
  {
    if(!empty(myQueue))
    {
       //Do work and deque
   }
 }
 else
 {
     //Try and make condition ok. Like reconect dongle.
 }
  // sleep/Back off for a while
}

Answer 1

You could use an existing library, like Glib. GLib is cross platform. If you used GLib’s asynchronous queues, you’d do something like:

The first thread to create the queue executes:

GAsyncQueue *q = g_async_queue_new ();

Other threads can reference (show intent to use the queue) with:

g_async_queue_ref (q);

After this, any thread can ‘push’ items to the queue with:

struct queue_item i;
g_async_queue_push (q, ( (gpointer) (&i)));

And any thread can ‘pop’ items from the queue with:

struct queue_item *d = g_async_queue_pop (q);
/* Blocks until item is available.  */

Once a thread finishes using the queue and doesn’t care any more about it, it calls:

g_async_queue_unref (q);

Even the thread which created the queue needs to do this.

There are a bunch of other useful functions, which you can all read about on the page documenting them. Synchronization (locking/consistency/atomicity of operations) is taken care of by the library itself.