Проверить структуру данных на текущее время и удалить, если найдено?

Question

если я добавлю будущее время к массиву времени (время [0] может быть 14,05, время [1] может быть 14,00), как я могу непрерывно опрашивать массив, используя pthreads, чтобы проверить, было ли время в массиведостигнуто и, если есть, удалите время из массива.Если будет лучше структура данных, то любые предложения будут приветствоваться!

Пример:

#include <time.h>
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>


time_t alarmTimes [100];
int alarmIndex = 0;

void addTime(time_t futureTime)
{
    alarmTimes[alarmIndex] = futureTime;
    alarmIndex++;
}

/*void * checkTime()
{
    1.check alarmTimes[] for current time
    2. if true, delete that time from array
}*/

int main(void)
{
    while(1)
    {
        int sleepTime = 1;
        time_t = futureTime;
        futureTime = time(NULL);

        srand(time(NULL));
        future_time += rand() % 100;
        sleepTime += rand() % 6;

        addTime(futureTime);
        sleep(sleepTime);
    }
}

Answer 1

Возможное решение (обратите внимание, я принял ноль для обозначения неиспользуемого элемента в массиве alarmTimes):

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>


#define ALARMTIMES_SIZE 100
time_t alarmTimes [ALARMTIMES_SIZE];
pthread_mutex_t alarmTimesLock;
int alarmIndex = 0;
volatile int isApplicationExiting = 0;

void addTime(time_t futureTime)
{
    pthread_mutex_lock(&alarmTimesLock);

    if (alarmIndex < ALARMTIMES_SIZE &&
        0 == alarmTimes[alarmIndex])
    {
        alarmTimes[alarmIndex] = futureTime;
        alarmIndex++;
    }
    else
    {
        /* Search for unused alarm time slot. */
        for (alarmIndex = 0; alarmIndex < ALARMTIMES_SIZE; alarmIndex++)
        {
            if (0 == alarmTimes[alarmIndex])
            {
                alarmTimes[alarmIndex] = futureTime;
                alarmIndex++;
            }
        }
    }

    pthread_mutex_unlock(&alarmTimesLock);
}

void* checkTime(void*)
{
    while (!isApplicationExiting)
    {
        pthread_mutex_lock(&alarmTimesLock);
        const time_t now = time(NULL);

        for (size_t i = 0; i < ALARMTIMES_SIZE; i++)
        {
             if (now == alarmTimes[i])
             {
                 printf("Removing alarm time at index %d\n", i);
                 alarmTimes[i] = 0;
             }
        }

        pthread_mutex_unlock(&alarmTimesLock);
        sleep(1);
    }

    return (void*)0;
}

int main(void)
{
    /*** No checking of pthread return values - you must do this. ***/

    /* Create lock. */
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
    pthread_mutex_init(&alarmTimesLock, &attr);

    /* Start thread. */
    pthread_attr_t threadAttributes;
    pthread_t threadHandle;
    pthread_attr_init(&threadAttributes);
    pthread_attr_setdetachstate(&threadAttributes, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threadHandle, &threadAttributes, checkTime, (void*)0);

    memset(alarmTimes, 0, sizeof(alarmTimes));
    for (;;)
    {
        int sleepTime = 1;
        time_t futureTime;
        futureTime = time(NULL);

        srand(time(NULL));
        futureTime += rand() % 100;
        sleepTime += rand() % 6;

        addTime(futureTime);
        sleep(sleepTime);
    }

    /* Stop thread and tidy. */
    isApplicationExiting = 1;
    pthread_join(threadHandle, 0);
    pthread_mutex_destroy(&alarmTimesLock);

    return 0;
}

Надеюсь, это поможет.