This is a programming assignment that requires t
he use of POSIX threads, mutex locks, and/or semaphores to coordinate t
he activities of t
he TA and t
he students
. Here is one possible solution:
1
. Create a mutex lock and two semaphores: one for t
he TA and one for t
he students waiting in t
he hallway
.
2. Create N student threads and one TA thread
.
3
. Each student thread should loop indefinitely, alternating between programming and seeking
help from t
he TA
.
4
. W
hen a student needs
help, t
hey should try to acquire t
he mutex lock
. If t
he TA is sleeping, t
he student should signal t
he TA semaphore and wait on t
he student semaphore
. If t
he TA is
helping anot
her student, t
he student should wait on t
he student semaphore
.
5
. W
hen t
he TA wakes
up, t
hey should try to acquire t
he mutex lock
. If t
here are students waiting in t
he hallway, t
he TA should signal t
he student semaphore N times to wake
up t
he students
. T
he TA should t
hen
help each student in turn, releasing t
he mutex lock after each one is
helped
.
6
. If t
here are no students waiting, t
he TA should release t
he mutex lock and go back to sleep
.
Here is some sample code to implement this solution:
```
#include <pthread
.h>
#include <semaphore
.h>
#include <stdio
.h>
#include <stdlib
.h>
#include <unistd
.h>
#define N 10 // number of students
#define CHAIRS 3 // number of chairs in hallway
pthread_t students[N], ta;
pthread_mutex_t mutex;
sem_t student_sem, ta_sem;
int waiting = 0;
void *student
(void *arg
) {
int id = *
(int*
)arg;
while
(1
) {
// program for a random amount of time
sleep
(rand
() % 10 + 1
);
printf
("Student %d needs
help\n", id
);
pthread_mutex_lock
(&mutex
);
if
(waiting < CHAIRS
) {
// t
here is a free chair in t
he hallway
waiting++;
printf
("Student %d waiting in hallway
(%d/%d
)\n", id, waiting, CHAIRS
);
pthread_mutex_unlock
(&mutex
);
sem_wait
(&student_sem
);
waiting
--;
} else {
// no free chairs in t
he hallway
printf
("Student %d will come back later\n", id
);
pthread_mutex_unlock
(&mutex
);
}
// get
help from TA
printf
("Student %d getting
help from TA\n", id
);
//
help for a random amount of time
sleep
(rand
() % 5 + 1
);
}
}
void *ta_
helper
(void *arg
) {
while
(1
) {
// sleep until a student wakes us
up
sem_wait
(&ta_sem
);
while
(1
) {
pthread_mutex_lock
(&mutex
);
if
(waiting == 0
) {
// no students waiting, go back to sleep
pthread_mutex_unlock
(&mutex
);
break;
}
//
help t
he next student in line
waiting
--;
sem_post
(&student_sem
);
printf
("TA
helping a student
(%d/%d
)\n", waiting, CHAIRS
);
pthread_mutex_unlock
(&mutex
);
//
help for a random amount of time
sleep
(rand
() % 5 + 1
);
}
}
}
int main
() {
// initialize mutex lock and semaphores
pthread_mutex_init
(&mutex, NULL
);
sem_init
(&student_sem, 0, 0
);
sem_init
(&ta_sem, 0, 0
);
// create student threads
int student_ids[N];
for
(int i = 0; i < N; i++
) {
student_ids[i] = i;
pthread_create
(&students[i], NULL, student, &student_ids[i]
);
}
// create TA thread
pthread_create
(&ta, NULL, ta_
helper, NULL
);
// wait for threads to finish
for
(int i = 0; i < N; i++
) {
pthread_
join(students[i], NULL
);
}
pthread_
join(ta, NULL
);
// clean
up mutex lock and semaphores
pthread_mutex_destroy
(&mutex
);
sem_destroy
(&student_sem
);
sem_destroy
(&ta_sem
);
return 0;
}
```
Note that this is just one possible solution and t
here may be ot
her ways to implement t
he same behavior using different
synchronization primitives
.
本文介绍了计算机科学中两种主要的同步概念：进程同步与数据同步。进程同步涉及多个进程之间的协调，确保它们能够达成一致行动；数据同步则关注于保持多份数据集的一致性。文章还探讨了如何使用进程同步原语来实现数据同步。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
