求！

轻语远歌

有一个全局数组int arr[]={1,2,3,4,5,6,7,8,9,10}，现需要使用两个线程按顺序交替将数组内容打印出来（每个线程打印一次，直到全部打印完），不允许使用延时函数

FishC

要实现两个线程交替打印数组中的元素，我们可以使用互斥锁（Mutex）和条件变量（Condition Variable）来同步线程。确保每个线程在正确的时机打印出正确的值。以下是使用C语言实现的简单示例：

1. #include <stdio.h>
   
2. #include <pthread.h>
   
3. 
   
4. #define SIZE 10
   
5. 
   
6. int arr[SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   
7. int index = 0;  // 用于跟踪打印的数组下标
   
8. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
   
9. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
   
10. int turn = 0;  // 用于记录该哪个线程打印，0表示线程1，1表示线程2
    
11. 
    
12. void* print_even(void* arg) {
    
13.     while (1) {
    
14.         pthread_mutex_lock(&mutex);
    
15. 
    
16.         while (turn != 0 && index < SIZE) {
    
17.             pthread_cond_wait(&cond, &mutex);
    
18.         }
    
19. 
    
20.         if (index < SIZE) {
    
21.             printf("Thread 1: %d\n", arr[index]);
    
22.             index++;
    
23.             turn = 1;  // 切换到线程2
    
24.         }
    
25. 
    
26.         pthread_cond_signal(&cond);
    
27.         pthread_mutex_unlock(&mutex);
    
28. 
    
29.         if (index >= SIZE) break;
    
30.     }
    
31.     return NULL;
    
32. }
    
33. 
    
34. void* print_odd(void* arg) {
    
35.     while (1) {
    
36.         pthread_mutex_lock(&mutex);
    
37. 
    
38.         while (turn != 1 && index < SIZE) {
    
39.             pthread_cond_wait(&cond, &mutex);
    
40.         }
    
41. 
    
42.         if (index < SIZE) {
    
43.             printf("Thread 2: %d\n", arr[index]);
    
44.             index++;
    
45.             turn = 0;  // 切换到线程1
    
46.         }
    
47. 
    
48.         pthread_cond_signal(&cond);
    
49.         pthread_mutex_unlock(&mutex);
    
50. 
    
51.         if (index >= SIZE) break;
    
52.     }
    
53.     return NULL;
    
54. }
    
55. 
    
56. int main() {
    
57.     pthread_t t1, t2;
    
58. 
    
59.     pthread_create(&t1, NULL, print_even, NULL);
    
60.     pthread_create(&t2, NULL, print_odd, NULL);
    
61. 
    
62.     pthread_join(t1, NULL);
    
63.     pthread_join(t2, NULL);
    
64. 
    
65.     return 0;
    
66. }

复制代码

解释：
- 使用两个线程 `t1` 和 `t2` 分别调用 `print_even` 和 `print_odd` 函数。
- 线程间通过 `turn` 变量来决定该哪个线程打印。
- `pthread_mutex_lock` 和 `pthread_mutex_unlock` 用于锁定和解锁，以防止打印顺序的错乱。
- `pthread_cond_wait` 和 `pthread_cond_signal` 用来挂起和唤醒线程，实现交替运行。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

轻语远歌

FishC 发表于 2024-10-16 18:15
要实现两个线程交替打印数组中的元素，我们可以使用互斥锁（Mutex）和条件变量（Condition Variable）来同 ...

使用sem_wait还有sem_post实现线程
同步操作

FishC

轻语远歌 发表于 2024-10-16 18:26
使用sem_wait还有sem_post实现线程
同步操作

好的，我们可以使用信号量（Semaphore）来实现两个线程的同步，达到交替打印数组的目的。下面是通过C语言使用 `sem_wait` 和 `sem_post` 实现的一个示例：

1. #include <stdio.h>
   
2. #include <pthread.h>
   
3. #include <semaphore.h>
   
4. 
   
5. #define SIZE 10
   
6. 
   
7. int arr[SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   
8. int index = 0;  // 用于跟踪打印的数组下标
   
9. sem_t sem1, sem2;  // 信号量
   
10. 
    
11. void* print_even(void* arg) {
    
12.     while (1) {
    
13.         sem_wait(&sem1);  // 等待信号量1
    
14. 
    
15.         if (index < SIZE) {
    
16.             printf("Thread 1: %d\n", arr[index]);
    
17.             index++;
    
18.         }
    
19. 
    
20.         sem_post(&sem2);  // 释放信号量2
    
21. 
    
22.         if (index >= SIZE) break;
    
23.     }
    
24.     return NULL;
    
25. }
    
26. 
    
27. void* print_odd(void* arg) {
    
28.     while (1) {
    
29.         sem_wait(&sem2);  // 等待信号量2
    
30. 
    
31.         if (index < SIZE) {
    
32.             printf("Thread 2: %d\n", arr[index]);
    
33.             index++;
    
34.         }
    
35. 
    
36.         sem_post(&sem1);  // 释放信号量1
    
37. 
    
38.         if (index >= SIZE) break;
    
39.     }
    
40.     return NULL;
    
41. }
    
42. 
    
43. int main() {
    
44.     pthread_t t1, t2;
    
45. 
    
46.     // 初始化信号量，sem1初始值为1（让线程1先运行），sem2初始值为0
    
47.     sem_init(&sem1, 0, 1);
    
48.     sem_init(&sem2, 0, 0);
    
49. 
    
50.     // 创建线程
    
51.     pthread_create(&t1, NULL, print_even, NULL);
    
52.     pthread_create(&t2, NULL, print_odd, NULL);
    
53. 
    
54.     // 等待线程结束
    
55.     pthread_join(t1, NULL);
    
56.     pthread_join(t2, NULL);
    
57. 
    
58.     // 销毁信号量
    
59.     sem_destroy(&sem1);
    
60.     sem_destroy(&sem2);
    
61. 
    
62.     return 0;
    
63. }

复制代码

解释：
- 信号量 `sem1` 和 `sem2` 用于控制线程执行的顺序。
- `sem1` 初始值为1，表示线程1先可以执行。`sem2` 初始值为0，表示线程2需要等待。
- 在 `print_even` 函数中，`sem_wait(&sem1)` 等待信号量 `sem1`，表示线程1需要运行，然后 `sem_post(&sem2)` 释放信号量2，让线程2可以运行。
- 在 `print_odd` 函数中，`sem_wait(&sem2)` 等待信号量 `sem2`，表示线程2需要运行，然后 `sem_post(&sem1)` 释放信号量1，让线程1可以运行。
- 这样的交替机制确保了两个线程按顺序交替打印数组元素。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。