在Linux中，readdir函数用于读取目录的内容。当多个进程或线程并发访问同一个目录时，可能会出现竞争条件，导致数据不一致或其他问题。为了处理这种情况，可以采取以下几种方法：

1. 使用互斥锁（Mutex）： 互斥锁是一种同步机制，用于确保在同一时间只有一个线程可以访问共享资源。在使用readdir之前，可以先锁定一个互斥锁，读取完目录内容后再解锁。这样可以确保在同一时间只有一个线程在访问目录。

   #include 
   #include 
   #include 
   
   pthread_mutex_t dir_mutex = PTHREAD_MUTEX_INITIALIZER;
   
   void* read_directory(void* arg) {
       DIR *dir;
       struct dirent *entry;
   
       pthread_mutex_lock(&dir_mutex);
       dir = opendir(".");
       if (dir == NULL) {
           perror("opendir");
           pthread_mutex_unlock(&dir_mutex);
           return NULL;
       }
   
       while ((entry = readdir(dir)) != NULL) {
           printf("%s\n", entry->d_name);
       }
   
       closedir(dir);
       pthread_mutex_unlock(&dir_mutex);
       return NULL;
   }
   
   int main() {
       pthread_t threads[5];
   
       for (int i = 0; i < 5; ++i) {
           pthread_create(&threads[i], NULL, read_directory, NULL);
       }
   
       for (int i = 0; i < 5; ++i) {
           pthread_join(threads[i], NULL);
       }
   
       return 0;
   }
   

2. 使用文件锁（File Locking）： 文件锁是一种用于控制多个进程对文件的访问的机制。可以使用fcntl函数来实现文件锁。在读取目录之前，可以先获取一个共享锁，读取完目录内容后再释放锁。

   #include 
   #include 
   #include 
   #include 
   
   void read_directory(const char *path) {
       int fd = open(path, O_RDONLY);
       if (fd == -1) {
           perror("open");
           return;
       }
   
       struct flock lock;
       lock.l_type = F_RDLCK;
       lock.l_whence = SEEK_SET;
       lock.l_start = 0;
       lock.l_len = 0;
   
       if (fcntl(fd, F_SETLK, &lock) == -1) {
           perror("fcntl");
           close(fd);
           return;
       }
   
       DIR *dir = opendir(path);
       if (dir == NULL) {
           perror("opendir");
           close(fd);
           return;
       }
   
       struct dirent *entry;
       while ((entry = readdir(dir)) != NULL) {
           printf("%s\n", entry->d_name);
       }
   
       closedir(dir);
       lock.l_type = F_UNLCK;
       fcntl(fd, F_SETLK, &lock);
       close(fd);
   }
   
   int main() {
       read_directory(".");
       return 0;
   }
   

3. 使用原子操作： 如果只是需要统计目录中的文件数量或其他简单的操作，可以使用原子操作来避免竞争条件。例如，可以使用atomic_fetch_add等原子操作函数。

4. 避免并发访问： 如果可能的话，尽量避免多个进程或线程同时访问同一个目录。可以通过设计程序逻辑来实现这一点，例如，使用队列来管理目录访问请求。

总之，处理并发访问的关键在于确保在同一时间只有一个进程或线程在访问共享资源。根据具体的需求和场景，可以选择合适的同步机制来实现这一点。