c - 已解决的 sleep 方法会挂起 C pthreads 中的程序线程(竞争条件，与 sleep 无关)

标签 c pthreads

我创建了一个带有 pthreads 的 C 程序，它工作得很好，直到我添加任何类型的 sleep 函数，无论是 sleep()、usleep() 还是 nanosleep()。

是的，在你问之前，我知道 usleep() 已被弃用，并且我已经从另一篇 stackoferflow 帖子中复制了 nanosleep() 的正确用法，但即使 sleep() 也不起作用。

代码(关键部分位于“clients”线程中，第 99 行):

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

#define LIBERA 0
#define OCCUPATA 1
#define TUTTE_SEDIE_OCCUPATE -1
#define OCCUPATA_DA_BARBIERE -2

#define NRCLIENTI 10
#define NRSEDIE 5

pthread_mutex_t poltrona_m, dorme_m, get_sedia_m, occupa_sedia_m;
sem_t sem;
int sedia_taglio = LIBERA, sedia_attesa[NRSEDIE];

void init_attr(void) {
    int i;
    for (i = 0; i < NRSEDIE; i++)
        sedia_attesa[i] = LIBERA;
    sem_init(&sem, 0, NRSEDIE);
    pthread_mutex_unlock(&poltrona_m);
    pthread_mutex_unlock(&dorme_m);
    pthread_mutex_unlock(&get_sedia_m);
    pthread_mutex_unlock(&occupa_sedia_m);
}

int my_sleep(long millis) {
    struct timespec req, rem;

    if (millis > 999) {
        req.tv_sec = (int) (millis / 1000);
        req.tv_nsec = (millis - ((long) req.tv_sec * 1000)) * 1000000;
    } else {
        req.tv_sec = 0;
        req.tv_nsec = millis * 1000000;
    }

    return nanosleep(&req, &rem);
}

int get_sedia_libera() {
    pthread_mutex_lock(&get_sedia_m);
    int i;
    for (i = 0; i < NRSEDIE; i++)
        if (sedia_attesa[i] == LIBERA)
            return i;
    pthread_mutex_unlock(&get_sedia_m);
    return TUTTE_SEDIE_OCCUPATE;
}

int occupa_sedia(int index) {
    pthread_mutex_lock(&occupa_sedia_m);
    int result;
    if(sedia_attesa[index] == LIBERA){
        sedia_attesa[index] = OCCUPATA;
        result = 1;
    }else
        result = 0;
    pthread_mutex_unlock(&occupa_sedia_m);
    return result;
}

void libera_sedia(int index) {
    sedia_attesa[index] = LIBERA;
}

void *barbiere(void *arg) {
    while (1)
    {
        if (sedia_taglio == OCCUPATA) {
            pthread_mutex_lock(&poltrona_m);
            sedia_taglio = LIBERA;
            pthread_mutex_unlock(&poltrona_m);
        }

        if (get_sedia_libera() == 0 && sedia_taglio == LIBERA) {
            sedia_taglio = OCCUPATA_DA_BARBIERE;
            pthread_mutex_lock(&dorme_m);
            printf("[BARBIERE] il barbiere dorme...\n");
        }
    }
}

void *cliente(void *arg) {
    int n;
    int *id = (void *)arg;

    while (1)
    {
        if (sedia_taglio == LIBERA || sedia_taglio == OCCUPATA_DA_BARBIERE) {

            pthread_mutex_lock(&poltrona_m);
            pthread_mutex_unlock(&dorme_m);
            sedia_taglio = OCCUPATA;
            printf("----[CLIENTE] Cliente \"%d\" si taglia i capelli!\n", *id);
            my_sleep(2000);
            sedia_taglio = LIBERA;
            pthread_mutex_unlock(&poltrona_m);
            pthread_exit(0);

        } else {
            n = get_sedia_libera();
            if(n == TUTTE_SEDIE_OCCUPATE) {
                fprintf(stderr, "----[CLIENTE] No posti liberi cliente \"%d\" lascia il negozio\n", *id);
                pthread_exit((void *)1);
            } else {
                sem_wait(&sem);
                n = get_sedia_libera();
                if(occupa_sedia(n) && n != TUTTE_SEDIE_OCCUPATE){
                    printf("----[CLIENTE] Cliente \"%d\" aspetta su sedia #%d\n", *id, n+1);
                    while (sedia_taglio != LIBERA);
                    sem_post(&sem);
                    libera_sedia(n);
                } else {
                    sem_post(&sem);
                    fprintf(stderr, "----[CLIENTE] No posti liberi cliente \"%d\" lascia il negozio\n", *id);
                    pthread_exit(0);
                }
            }
        }

    }
}

int main(int argc, char **argv) {

    init_attr();

    int i, id[NRCLIENTI];
    pthread_t barbiere_thread, cliente_thread[NRCLIENTI];

    if(pthread_create(&barbiere_thread, NULL, barbiere, NULL ) < 0){
        fprintf(stderr, "[MAIN] Error creating \"barber\" thread!\n");
        exit(EXIT_FAILURE);
    }
    printf("[MAIN] thread \"barber\" creato\n\n");

    for (i = 0; i < NRCLIENTI; ++i) {
        id[i] = i+1;
        printf("[MAIN] thread \"client %d\" creato\n", id[i]);
        if(pthread_create(&cliente_thread[i], NULL, cliente, &id[i]) < 0){
            fprintf(stderr, "[MAIN] Error creating \"client %d\" thread!\n", id[i]);
            exit(EXIT_FAILURE);
        }
    }

    for (i = 0; i < NRCLIENTI; i++){
        pthread_join(cliente_thread[i], NULL);
        printf("[MAIN]Joined client \"%d\"\n", i+1);
    }

    //il programma non finira mai se sta ad aspettare un thread con un ciclo while(1) al suo interno
    //senza condizioni di break!!!
    pthread_join(barbiere_thread, NULL);

    return 0;
}

正常执行(这是程序应该工作的方式):

[MAIN] thread "client 1" creato
[BARBIERE] il barbiere dorme...
hey
[MAIN] thread "client 2" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "1" si taglia i capelli!
[MAIN] thread "client 3" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "2" si taglia i capelli!
[MAIN] thread "client 4" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "3" si taglia i capelli!
[MAIN] thread "client 5" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "4" si taglia i capelli!
[MAIN] thread "client 6" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "5" si taglia i capelli!
[MAIN] thread "client 7" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "6" si taglia i capelli!
[MAIN] thread "client 8" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "7" si taglia i capelli!
[MAIN] thread "client 9" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "8" si taglia i capelli!
[MAIN] thread "client 10" creato
----<<<<<<<<<<<<[CLIENTE] Cliente "9" si taglia i capelli!
----<<<<<<<<<<<<[CLIENTE] Cliente "10" si taglia i capelli!
[MAIN]Joined client "1"
[MAIN]Joined client "2"
[MAIN]Joined client "3"
[MAIN]Joined client "4"
[MAIN]Joined client "5"
[MAIN]Joined client "6"
[MAIN]Joined client "7"
[MAIN]Joined client "8"
[MAIN]Joined client "9"
[MAIN]Joined client "10"

使用任何 sleep 方法、sleep(1)、nanosleep() 执行 1 秒或 100k 微秒 usleep() 但是我没有考虑 usleep()，因为 a) *它已被弃用并且 * b) 你不能输入超过或等于 100 万微秒； usleep(1000000) 无效

[MAIN] thread "client 1" creato
[BARBIERE] il barbiere dorme...
[MAIN] thread "client 2" creato
----[CLIENTE] Cliente "1" si taglia i capelli!
[MAIN] thread "client 3" creato
[MAIN] thread "client 4" creato
[MAIN] thread "client 5" creato
[MAIN] thread "client 6" creato
[MAIN] thread "client 7" creato
[MAIN] thread "client 8" creato
[MAIN] thread "client 9" creato
[MAIN] thread "client 10" creato
[MAIN]Joined client "1"

正如您所看到的，线程只是......停滞。我在终端打开的情况下等待了 5 分钟，但仍然没有任何变化。 最奇怪的是，如果我使用 MinGW 在 Windows IntelliJ Clion 中运行它， sleep() 函数似乎完全被忽略(程序在不到一秒的时间内执行自身)!

感谢您阅读所有内容，我希望我们能够找到解决方案，对于我得到的任何帮助，我将不胜感激!

最佳答案

由于线程之间存在竞争条件，因此会造成死锁。

移动pthread_mutex_t poltrona_m, dorme_m, get_sedia_m, ocpa_sedia_m; 在全局范围内，添加这些详细函数:

const char * whoIam()
{
  if (pthread_self() == barbiere_thread)
    return "barbiere";

  for (int i = 0; i != NRCLIENTI; ++i) {
    if (pthread_self() == cliente_thread[i]) {
      static char str[NRCLIENTI][64];

      sprintf(str[i], "cliente %d", i+1); /* done several times but whatever */
      return str[i];
    }
  } 

  return "unknown-thread";
}

const char * whoIsMutex(pthread_mutex_t * m)
{
  if (m == &poltrona_m)
    return "poltrona";
  if (m == &dorme_m)
    return "dorme";
  if (m == &get_sedia_m)
    return "sedia";
  if (m == &occupa_sedia_m)
    return "occupa_sedia";
  return "unknown-mutex";
}

void my_pthread_mutex_unlock(pthread_mutex_t * m)
{
  printf("%s unlock %s\n", whoIam(), whoIsMutex(m));
  pthread_mutex_unlock(m);
}

void my_pthread_mutex_lock(pthread_mutex_t * m)
{
  printf("%s want to lock %s\n", whoIam(), whoIsMutex(m));
  pthread_mutex_lock(m);
  printf("%s locked %s\n", whoIam(), whoIsMutex(m));
}

并在init_attr中使用my_pthread_mutex_lock和my_pthread_mutex_unlock执行可以是:

[MAIN] thread "barber" creato

[MAIN] thread "client 1" creato
barbiere want to lock sedia
barbiere locked sedia
barbiere want to lock dorme
barbiere locked dorme
cliente 1 want to lock poltrona
cliente 1 locked poltrona
cliente 1 unlock dorme           <<< does nothing because does not have it
----[CLIENTE] Cliente "1" si taglia i capelli!
[BARBIERE] il barbiere dorme...
barbiere want to lock poltrona   <<< wait while get by client 1
[MAIN] thread "client 2" creato
[MAIN] thread "client 3" creato
[MAIN] thread "client 4" creato
cliente 2 want to lock sedia
[MAIN] thread "client 5" creato
cliente 4 want to lock sedia
[MAIN] thread "client 6" creato
cliente 3 want to lock sedia
[MAIN] thread "client 7" creato
cliente 6 want to lock sedia
cliente 5 want to lock sedia
[MAIN] thread "client 8" creato
cliente 7 want to lock sedia
[MAIN] thread "client 9" creato
cliente 8 want to lock sedia
[MAIN] thread "client 10" creato
cliente 9 want to lock sedia
cliente 10 want to lock sedia
cliente 1 unlock poltrona     <<< finally unlock poltrona
barbiere locked poltrona      <<< wake up
barbiere unlock poltrona
barbiere want to lock sedia   <<< dead because get by itself
[MAIN]Joined client "1"

在 cliente 中的 sedia_taglio = ocpata; 之前添加 my_sleep(1000); 有助于避免竞争条件:

bruno@bruno-XPS-8300:/tmp$ gcc -Wall t.c -lpthread
bruno@bruno-XPS-8300:/tmp$ ./a.out
[MAIN] thread "barber" creato

[MAIN] thread "client 1" creato
[BARBIERE] il barbiere dorme...
[MAIN] thread "client 2" creato
[MAIN] thread "client 3" creato
[MAIN] thread "client 4" creato
[MAIN] thread "client 5" creato
[MAIN] thread "client 6" creato
[MAIN] thread "client 7" creato
[MAIN] thread "client 8" creato
[MAIN] thread "client 9" creato
[MAIN] thread "client 10" creato
----[CLIENTE] Cliente "1" si taglia i capelli!
[MAIN]Joined client "1"
----[CLIENTE] Cliente "3" si taglia i capelli!
----[CLIENTE] Cliente "2" si taglia i capelli!
[MAIN]Joined client "2"
[MAIN]Joined client "3"
----[CLIENTE] Cliente "4" si taglia i capelli!
[MAIN]Joined client "4"
----[CLIENTE] Cliente "5" si taglia i capelli!
[MAIN]Joined client "5"
----[CLIENTE] Cliente "6" si taglia i capelli!
[MAIN]Joined client "6"
----[CLIENTE] Cliente "7" si taglia i capelli!
[MAIN]Joined client "7"
----[CLIENTE] Cliente "8" si taglia i capelli!
[MAIN]Joined client "8"
----[CLIENTE] Cliente "9" si taglia i capelli!
[MAIN]Joined client "9"
----[CLIENTE] Cliente "10" si taglia i capelli!
[MAIN]Joined client "10"

其中，关于sleep的方式，函数sleep会阻塞所有的进程，与usleep和nanosleep相反。

这里是一个没有竞争条件的提案，也没有对互斥体实现做出假设(没有未定义的行为)。

只有一个互斥体来保护数据一致性，在条件允许的情况下，我也用它来保护打印。

有座位等待，还有一个用来理发的。为了按到达顺序管理客户，他们会获得一张带有号码的票，当根本没有空闲座位时，客户将无法获得票，并将稍后重试。客户理发的票号由 CurrentTicket 给出(作为屏幕客户读取)，并产生信号 NextClient (作为蜂鸣声)以允许客户检查是否轮到他们。分配器中的票号由LastTicket管理。信号 HelloBarber 是由客户在到达理发师处时发送的，并且可能会唤醒他。没有顾客的时候理发师就 sleep 。

我使用限制为 5 秒的随机时间来延迟客户(重新)尝试获得位置的延迟，而理发师在限制为 3 秒的随机时间内为客户理发。

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

#define NCLIENT 10
#define NSEAT 5 /* seats to wait */

unsigned int Seed;
int Nseat = NSEAT  + 1; /* add 1 to have seat to cut hairs */
int CurrentTicket = 0;
int LastTicket = 0;

pthread_mutex_t Mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t NextClient = PTHREAD_COND_INITIALIZER;
pthread_cond_t HelloBarber = PTHREAD_COND_INITIALIZER;

/* return -1 is no seat, else ticket number */
int getTicket()
{
  int result;

  pthread_mutex_lock(&Mutex);
  if (Nseat == 0)
    result = -1;
  else {
    Nseat -= 1;
    result = ++LastTicket;
  }
  pthread_mutex_unlock(&Mutex);

  return result;
}

void randomSleep(int max)
{
  int millis = rand_r(&Seed) % (max * 1000);
  struct timespec req, rem;

  if (millis > 999) {
    req.tv_sec = (int) (millis / 1000);
    req.tv_nsec = (millis - ((long) req.tv_sec * 1000)) * 1000000;
  } else {
    req.tv_sec = 0;
    req.tv_nsec = millis * 1000000;
  }

  nanosleep(&req, &rem);
}

void * client(void * arg)
{
  int id = *((int *) arg);
  int ticket;
  int justArrived = 1;

  while (randomSleep(5), ((ticket = getTicket()) == -1)) {
    pthread_mutex_lock(&Mutex);
    printf("----[CLIENT] Client \"%d\" no place, will try again later\n", id);
    pthread_mutex_unlock(&Mutex);
  }

  pthread_mutex_lock(&Mutex);
  printf("----[CLIENT] Client \"%d\" got ticket number %d\n", id, ticket);

  while (ticket != CurrentTicket) {
    printf("----[CLIENT] Client \"%d\" not my turn\n", id);
    if (justArrived) {
      justArrived = 0;
      printf("----[CLIENT] Client \"%d\" seat to wait\n", id);
    }
    pthread_cond_wait(&NextClient, &Mutex);
  }
  printf("----[CLIENT] Client \"%d\" my turn\n", id);
  if (justArrived)
    printf("----[CLIENT] Client \"%d\" do not need to seat to wait\n", id);

  pthread_cond_signal(&HelloBarber);

  pthread_cond_wait(&NextClient, &Mutex);
  printf("----[CLIENT] Client \"%d\" done for me\n", id);
  pthread_mutex_unlock(&Mutex);

  return NULL;
}

void * barber(void * dummy)
{
  pthread_mutex_lock(&Mutex);

  puts("[BARBER] ready");
  CurrentTicket = 1;
  pthread_cond_signal(&NextClient);

  for (;;) {
    printf("[BARBER] screen indicates ticket %d\n", CurrentTicket);

    int sleep = (Nseat == NSEAT + 1);

    if (sleep)
      puts("[BARBER] no client, time to sleep");

    pthread_cond_wait(&HelloBarber, &Mutex); /* in all cases to be sure next client had time to see his turn */

    if (sleep)
      puts("[BARBER] woken up by a client");
    puts("[BARBER] cutting hairs");

    pthread_mutex_unlock(&Mutex);
    randomSleep(3); /* time to cut hairs of current client */
    pthread_mutex_lock(&Mutex);

    puts("[BARBER] haircut done");
    Nseat += 1;
    CurrentTicket += 1;
    pthread_cond_broadcast(&NextClient);
  }
}

int main()
{
  pthread_t barber_thread, client_thread[NCLIENT];
  int i, id[NCLIENT];

  Seed = time(NULL);

  if (pthread_create(&barber_thread, NULL, barber, NULL ) < 0){
    fprintf(stderr, "[MAIN] Error creating \"barber\" thread!\n");
    exit(EXIT_FAILURE);
  }

  pthread_mutex_lock(&Mutex);
  if (CurrentTicket == 0) {
    /* wait barber ready */
    pthread_cond_wait(&NextClient, &Mutex);
  }
  pthread_mutex_unlock(&Mutex);

  for (i = 0; i < NCLIENT; ++i) {
    id[i] = i+1;
    if (pthread_create(&client_thread[i], NULL, client, &id[i]) < 0) {
      fprintf(stderr, "[MAIN] Error creating \"client %d\" thread!\n", id[i]);
      exit(EXIT_FAILURE);
    }
  }

  for (i = 0; i < NCLIENT; i++) {
    pthread_join(client_thread[i], NULL);

    pthread_mutex_lock(&Mutex);
    printf("[MAIN] Joined client \"%d\"\n", i+1);
    pthread_mutex_unlock(&Mutex);
  }

  return 0;
}

编译和执行示例:

pi@raspberrypi:~ $ gcc -Wall barber.c  -lpthread
pi@raspberrypi:~ $ ./a.out
[BARBER] ready
[BARBER] screen indicates ticket 1
[BARBER] no client, time to sleep
----[CLIENT] Client "7" got ticket number 1
----[CLIENT] Client "7" my turn
----[CLIENT] Client "7" do not need to seat to wait
[BARBER] woken up by a client
[BARBER] cutting hairs
----[CLIENT] Client "6" got ticket number 2
----[CLIENT] Client "6" not my turn
----[CLIENT] Client "6" seat to wait
----[CLIENT] Client "5" got ticket number 3
----[CLIENT] Client "5" not my turn
----[CLIENT] Client "5" seat to wait
----[CLIENT] Client "1" got ticket number 4
----[CLIENT] Client "1" not my turn
----[CLIENT] Client "1" seat to wait
----[CLIENT] Client "3" got ticket number 5
----[CLIENT] Client "3" not my turn
----[CLIENT] Client "3" seat to wait
[BARBER] haircut done
[BARBER] screen indicates ticket 2
----[CLIENT] Client "7" done for me
----[CLIENT] Client "3" not my turn
----[CLIENT] Client "1" not my turn
----[CLIENT] Client "6" my turn
----[CLIENT] Client "5" not my turn
[BARBER] cutting hairs
----[CLIENT] Client "9" got ticket number 6
----[CLIENT] Client "9" not my turn
----[CLIENT] Client "9" seat to wait
----[CLIENT] Client "8" got ticket number 7
----[CLIENT] Client "8" not my turn
----[CLIENT] Client "8" seat to wait
----[CLIENT] Client "4" no place, will try again later
----[CLIENT] Client "2" no place, will try again later
----[CLIENT] Client "10" no place, will try again later
[BARBER] haircut done
[BARBER] screen indicates ticket 3
----[CLIENT] Client "8" not my turn
----[CLIENT] Client "5" my turn
----[CLIENT] Client "9" not my turn
----[CLIENT] Client "1" not my turn
----[CLIENT] Client "6" done for me
[BARBER] cutting hairs
----[CLIENT] Client "3" not my turn
[BARBER] haircut done
[BARBER] screen indicates ticket 4
----[CLIENT] Client "9" not my turn
----[CLIENT] Client "1" my turn
----[CLIENT] Client "3" not my turn
----[CLIENT] Client "5" done for me
----[CLIENT] Client "8" not my turn
[BARBER] cutting hairs
[BARBER] haircut done
[BARBER] screen indicates ticket 5
----[CLIENT] Client "8" not my turn
----[CLIENT] Client "1" done for me
[MAIN] Joined client "1"
----[CLIENT] Client "9" not my turn
----[CLIENT] Client "3" my turn
[BARBER] cutting hairs
----[CLIENT] Client "10" got ticket number 8
----[CLIENT] Client "10" not my turn
----[CLIENT] Client "10" seat to wait
----[CLIENT] Client "2" got ticket number 9
----[CLIENT] Client "2" not my turn
----[CLIENT] Client "2" seat to wait
----[CLIENT] Client "4" got ticket number 10
----[CLIENT] Client "4" not my turn
----[CLIENT] Client "4" seat to wait
[BARBER] haircut done
[BARBER] screen indicates ticket 6
----[CLIENT] Client "2" not my turn
----[CLIENT] Client "3" done for me
----[CLIENT] Client "4" not my turn
----[CLIENT] Client "8" not my turn
----[CLIENT] Client "9" my turn
----[CLIENT] Client "10" not my turn
[BARBER] cutting hairs
[BARBER] haircut done
[BARBER] screen indicates ticket 7
----[CLIENT] Client "2" not my turn
----[CLIENT] Client "9" done for me
----[CLIENT] Client "4" not my turn
----[CLIENT] Client "8" my turn
[BARBER] cutting hairs
----[CLIENT] Client "10" not my turn
[BARBER] haircut done
[BARBER] screen indicates ticket 8
----[CLIENT] Client "10" my turn
[BARBER] cutting hairs
----[CLIENT] Client "2" not my turn
----[CLIENT] Client "8" done for me
----[CLIENT] Client "4" not my turn
[BARBER] haircut done
[BARBER] screen indicates ticket 9
----[CLIENT] Client "10" done for me
----[CLIENT] Client "2" my turn
----[CLIENT] Client "4" not my turn
[BARBER] cutting hairs
[BARBER] haircut done
[BARBER] screen indicates ticket 10
----[CLIENT] Client "2" done for me
----[CLIENT] Client "4" my turn
[BARBER] cutting hairs
[MAIN] Joined client "2"
[MAIN] Joined client "3"
[BARBER] haircut done
[BARBER] screen indicates ticket 11
[BARBER] no client, time to sleep
----[CLIENT] Client "4" done for me
[MAIN] Joined client "4"
[MAIN] Joined client "5"
[MAIN] Joined client "6"
[MAIN] Joined client "7"
[MAIN] Joined client "8"
[MAIN] Joined client "9"
[MAIN] Joined client "10"
pi@raspberrypi:~ $

关于c - 已解决的 sleep 方法会挂起 C pthreads 中的程序线程(竞争条件，与 sleep 无关)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/62118182/

上一篇：java - HTTP 是否允许服务器在消耗所有输入之前开始输出？如果是这样，如何用Java访问这样的服务器？

下一篇：laravel - 如何在 phpunit 测试中使用带有模拟缓存的缓存标签？

相关文章：

c - 为什么这些构造使用增量前和增量后未定义的行为？

c - 如何处理int中的特定数字

c - makefile 相对路径是否与 gcc 相对路径相同？

c++ - 线程特定数据与线程本地存储

c - 线程是否应该始终使用 while 循环来保存 pthread_cond_wait 语句？

c - 如何从控制台输入数字

c - 为什么 static char* 需要常量初始化，而 static char** 不需要

c - Pthread 条件语句

android - 在 Android 上加载 libpthread.so 时出错

c++ - 当取消请求排队时，pthread_cancel() 将如何响应？

©2024 IT工具网  联系我们