信号量似乎无法在多线程中正常工作
Semaphore doesn't seem to work correctly with multiple threads
我尝试用 C 编写多线程示例。这是从用户获取的数字和两个线程中的总和数字。
线程直接相互远离,从前到后,从后到前。
我正在使用信号量来管理全局变量,但输出显示信号量无法正常工作。
怎么了?
代码输出:
Array size? :10
Array of contents? :4 2 8 1 5 3 7 9 6 10
Thread_1 > read 4, sum is = 4
Thread_1 > read 2, sum is = 6
Thread_1 > read 8, sum is = 14
Thread_1 > read 1, sum is = 15
Thread_1 > read 5, sum is = 20
Thread_1 > read 3, sum is = 23
Thread_1 > read 7, sum is = 30
Thread_1 > read 9, sum is = 39
Thread_1 > read 6, sum is = 45
Thread_1 > read 10, sum is = 55
Thread_1 > End.
Thread_2 > End.
代码:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>
int *array; //Global integer array
int sum; //Global sum variable
int counter = 0;
sem_t mutex;
void *front_to_back( void *val )
{
int SIZE;
SIZE = *((int *) val);
while (1)
{
sem_wait(&mutex);
if( counter != SIZE )
{
sum = sum + array[counter];
printf("Thread_1 > read %d, sum is = %d \n", array[counter], sum);
counter++;
}else
{
printf("Thread_1 > End. \n");
sem_post(&mutex);
break;
}
sem_post(&mutex);
}
}
void *back_to_front( void *val )
{
int SIZE;
SIZE = *((int *) val);
int i=1;
while (1)
{
sem_wait(&mutex);
if( counter != SIZE )
{
sum = sum + array[SIZE - i];
printf("Thread_2 > read %d, sum is = %d \n", array[SIZE - i], sum);
counter++;
i++;
}else
{
printf("Thread_2 > End. \n");
sem_post(&mutex);
break;
}
sem_post(&mutex);
}
}
main(){
int SIZE;
printf("Array size? :");
scanf("%d", &SIZE);
array = malloc(SIZE*sizeof(int));
int i=0;
printf("Array of contents? :");
for (i ; i<SIZE ; i++)
{
scanf("%d", &array[i]);
}
pthread_t t[2];
sem_init(&mutex, 0, 1);
pthread_create(&t[1], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[2], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[1],NULL);
pthread_join(t[2],NULL);
free(array);
sem_destroy(&mutex);
}
您应该在 main()
中使用 t[0]
和 t[1]
:大小为 N
的数组在 0..N-1
中具有有效索引,因此,首先,解决这个问题。这是正确的代码:
pthread_create(&t[0], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[1], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[0],NULL);
pthread_join(t[1],NULL);
理想情况下,您还应该检查 malloc()
和 pthread_create()
是否成功。这些函数可能 return 出错,你应该处理它。您的代码忽略了错误(对于越界访问,您实际上很幸运它能正常工作)。
此外,为什么您将信号量当作互斥量来使用?这里并不真正需要信号量——当您不需要信号量的强大功能和灵活性时,只需使用互斥量即可。一个重要的区别是信号量允许您在一个线程上等待,post 在另一个线程上等待,而互斥量必须由获取它的线程解锁。
因此,在互斥锁就足够的情况下使用信号量可能会掩盖代码中的错误。所以,我会继续使用互斥锁。这是包含所有更改的代码:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
int *array; //Global integer array
int sum; //Global sum variable
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *front_to_back( void *val )
{
int SIZE;
SIZE = *((int *) val);
while (1)
{
pthread_mutex_lock(&mutex);
if( counter != SIZE )
{
sum = sum + array[counter];
printf("Thread_1 > read %d, sum is = %d \n", array[counter], sum);
counter++;
}else
{
printf("Thread_1 > End. \n");
pthread_mutex_unlock(&mutex);
break;
}
pthread_mutex_unlock(&mutex);
}
return NULL;
}
void *back_to_front( void *val )
{
int SIZE;
SIZE = *((int *) val);
int i=1;
while (1)
{
pthread_mutex_lock(&mutex);
if( counter != SIZE )
{
sum = sum + array[SIZE - i];
printf("Thread_2 > read %d, sum is = %d \n", array[SIZE - i], sum);
counter++;
i++;
}else
{
printf("Thread_2 > End. \n");
pthread_mutex_unlock(&mutex);
break;
}
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main(void) {
int SIZE;
printf("Array size? :");
scanf("%d", &SIZE);
array = malloc(SIZE*sizeof(int));
int i=0;
printf("Array of contents? :");
for (; i<SIZE ; i++)
{
scanf("%d", &array[i]);
}
pthread_t t[2];
pthread_create(&t[0], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[1], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[0],NULL);
pthread_join(t[1],NULL);
free(array);
return 0;
}
我第一眼看不出代码有任何其他问题。
现在,您的问题似乎是您没有看到任何并行性。您应该尝试使用更大的数组。单个线程可能能够在上下文切换之前处理一个 10 元素数组。
更新:我刚刚用 3000 个元素的数组尝试了代码。您可以清楚地看到它们是并行执行的。
我尝试用 C 编写多线程示例。这是从用户获取的数字和两个线程中的总和数字。
线程直接相互远离,从前到后,从后到前。
我正在使用信号量来管理全局变量,但输出显示信号量无法正常工作。
怎么了?
代码输出:
Array size? :10
Array of contents? :4 2 8 1 5 3 7 9 6 10
Thread_1 > read 4, sum is = 4
Thread_1 > read 2, sum is = 6
Thread_1 > read 8, sum is = 14
Thread_1 > read 1, sum is = 15
Thread_1 > read 5, sum is = 20
Thread_1 > read 3, sum is = 23
Thread_1 > read 7, sum is = 30
Thread_1 > read 9, sum is = 39
Thread_1 > read 6, sum is = 45
Thread_1 > read 10, sum is = 55
Thread_1 > End.
Thread_2 > End.
代码:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>
int *array; //Global integer array
int sum; //Global sum variable
int counter = 0;
sem_t mutex;
void *front_to_back( void *val )
{
int SIZE;
SIZE = *((int *) val);
while (1)
{
sem_wait(&mutex);
if( counter != SIZE )
{
sum = sum + array[counter];
printf("Thread_1 > read %d, sum is = %d \n", array[counter], sum);
counter++;
}else
{
printf("Thread_1 > End. \n");
sem_post(&mutex);
break;
}
sem_post(&mutex);
}
}
void *back_to_front( void *val )
{
int SIZE;
SIZE = *((int *) val);
int i=1;
while (1)
{
sem_wait(&mutex);
if( counter != SIZE )
{
sum = sum + array[SIZE - i];
printf("Thread_2 > read %d, sum is = %d \n", array[SIZE - i], sum);
counter++;
i++;
}else
{
printf("Thread_2 > End. \n");
sem_post(&mutex);
break;
}
sem_post(&mutex);
}
}
main(){
int SIZE;
printf("Array size? :");
scanf("%d", &SIZE);
array = malloc(SIZE*sizeof(int));
int i=0;
printf("Array of contents? :");
for (i ; i<SIZE ; i++)
{
scanf("%d", &array[i]);
}
pthread_t t[2];
sem_init(&mutex, 0, 1);
pthread_create(&t[1], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[2], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[1],NULL);
pthread_join(t[2],NULL);
free(array);
sem_destroy(&mutex);
}
您应该在 main()
中使用 t[0]
和 t[1]
:大小为 N
的数组在 0..N-1
中具有有效索引,因此,首先,解决这个问题。这是正确的代码:
pthread_create(&t[0], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[1], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[0],NULL);
pthread_join(t[1],NULL);
理想情况下,您还应该检查 malloc()
和 pthread_create()
是否成功。这些函数可能 return 出错,你应该处理它。您的代码忽略了错误(对于越界访问,您实际上很幸运它能正常工作)。
此外,为什么您将信号量当作互斥量来使用?这里并不真正需要信号量——当您不需要信号量的强大功能和灵活性时,只需使用互斥量即可。一个重要的区别是信号量允许您在一个线程上等待,post 在另一个线程上等待,而互斥量必须由获取它的线程解锁。
因此,在互斥锁就足够的情况下使用信号量可能会掩盖代码中的错误。所以,我会继续使用互斥锁。这是包含所有更改的代码:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
int *array; //Global integer array
int sum; //Global sum variable
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *front_to_back( void *val )
{
int SIZE;
SIZE = *((int *) val);
while (1)
{
pthread_mutex_lock(&mutex);
if( counter != SIZE )
{
sum = sum + array[counter];
printf("Thread_1 > read %d, sum is = %d \n", array[counter], sum);
counter++;
}else
{
printf("Thread_1 > End. \n");
pthread_mutex_unlock(&mutex);
break;
}
pthread_mutex_unlock(&mutex);
}
return NULL;
}
void *back_to_front( void *val )
{
int SIZE;
SIZE = *((int *) val);
int i=1;
while (1)
{
pthread_mutex_lock(&mutex);
if( counter != SIZE )
{
sum = sum + array[SIZE - i];
printf("Thread_2 > read %d, sum is = %d \n", array[SIZE - i], sum);
counter++;
i++;
}else
{
printf("Thread_2 > End. \n");
pthread_mutex_unlock(&mutex);
break;
}
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main(void) {
int SIZE;
printf("Array size? :");
scanf("%d", &SIZE);
array = malloc(SIZE*sizeof(int));
int i=0;
printf("Array of contents? :");
for (; i<SIZE ; i++)
{
scanf("%d", &array[i]);
}
pthread_t t[2];
pthread_create(&t[0], NULL, front_to_back, (void *) &SIZE );
pthread_create(&t[1], NULL, back_to_front, (void *) &SIZE );
pthread_join(t[0],NULL);
pthread_join(t[1],NULL);
free(array);
return 0;
}
我第一眼看不出代码有任何其他问题。
现在,您的问题似乎是您没有看到任何并行性。您应该尝试使用更大的数组。单个线程可能能够在上下文切换之前处理一个 10 元素数组。
更新:我刚刚用 3000 个元素的数组尝试了代码。您可以清楚地看到它们是并行执行的。