Dalam pengaturcaraan serentak, concurrency mewakili konsep utama yang diperlukan untuk memahami sepenuhnya cara sistem ini berfungsi. Di antara pelbagai cabaran yang dihadapi oleh pengamal yang bekerja dengan sistem ini, masalah pengeluar-pengguna adalah salah satu masalah penyegerakan yang paling terkenal. Dalam artikel ini, kami berhasrat untuk menganalisis topik ini dan menyerlahkan kepentingannya untuk pengkomputeran serentak, sambil turut meneroka kemungkinan penyelesaian berasaskan C.
Terjemahan bahasa Cina bagiDalam sistem serentak, berbilang urutan atau proses boleh mengakses sumber dikongsi pada masa yang sama. Masalah pengeluar-pengguna melibatkan dua entiti: pengeluar menjana data atau tugas, dan pengguna memproses atau menggunakan data yang dijana. Cabarannya adalah untuk memastikan pengeluar dan pengguna menyegerakkan aktiviti mereka untuk mengelakkan masalah seperti keadaan kaum atau konflik sumber.
Satu takrifan yang mungkin bagi masalah pengeluar-pengguna melibatkan dua kumpulan utama: pengeluar data menyimpan kerja mereka dalam ruang kongsi yang dipanggil penimbal dan pemproses (pengguna) menggunakan kandungan ruang yang disimpan. Individu ini menggunakan kepakaran mereka dalam mengumpulkan item dalam senario storan sementara ini, menganalisisnya secara menyeluruh, dan kemudian memberikan hasil yang bernas.
Menyelesaikan dilema pengeluar-pengguna semestinya melibatkan pelaksanaan teknologi kerjasama yang disegerakkan di kalangan pelbagai pihak berkepentingan. Mengoptimumkan penyepaduan protokol penyegerakan adalah penting untuk mengelakkan penimbal peranti dibebankan dengan menghasilkan unit atau keletihan oleh unit yang digunakan.
Dalam bahasa C, anda boleh menggunakan struktur data tatasusunan atau baris gilir untuk melaksanakan penimbal dikongsi. Penampan hendaklah mempunyai saiz tetap dan operasi sokongan seperti menambah data (pengeluar) dan mendapatkan semula data (pengguna).
Pelbagai teknik penyegerakan boleh digunakan untuk menyelesaikan masalah pengeluar-pengguna dalam bahasa C, termasuk −
Kunci Mutex dan pembolehubah keadaan − Kunci Mutex menyediakan perlindungan pengecualian bersama untuk bahagian kritikal kod, manakala pembolehubah keadaan membenarkan benang menunggu sehingga syarat tertentu dipenuhi.
Semaphore - Semaphore boleh mengawal akses kepada penimbal kongsi dengan menjejaki bilangan slot kosong dan penuh.
Monitor − Monitor menyediakan abstraksi peringkat lebih tinggi untuk penyegerakan dan merangkum data kongsi serta operasi yang boleh dilakukan padanya.
Penyelesaian biasa kepada masalah pengeluar-pengguna ialah penyelesaian penimbal terhad. Ia melibatkan penggunaan penimbal bersaiz tetap dengan mekanisme penyegerakan untuk memastikan pengeluar dan pengguna bekerjasama dengan betul. Kapasiti pengeluaran projek dihadkan oleh saiz penimbal, jadi perancangan mesti mengambil kira spesifikasi ini untuk mengelakkan melebihi ruang yang tersedia dalam penimbal.
Dalam bahasa C, aktiviti pengeluar dan pengguna boleh dilaksanakan sebagai benang yang berasingan. Setiap utas pengeluar menjana data dan menambahkannya pada penimbal dikongsi, manakala setiap utas pengguna mendapatkan semula data daripada penimbal dan memprosesnya. Mekanisme penyegerakan digunakan untuk menyelaraskan aktiviti benang.
Dalam senario dunia sebenar, faktor tambahan mungkin perlu dipertimbangkan. Contohnya, jika pengeluar menjana data pada kadar yang lebih pantas daripada pengguna boleh memprosesnya, anda mungkin perlu menggunakan mekanisme penimbalan seperti menyekat atau membuang data untuk mengelakkan kehilangan data atau situasi kebuntuan.
Penyelesaian penimbal terikat menggunakan mutex dan pembolehubah keadaan, dengan keadaan penamat.
Terjemahan bahasa Cina bagi
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define BUFFER_SIZE 5
#define MAX_ITEMS 5
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int produced_count = 0;
int consumed_count = 0;
pthread_mutex_t mutex;
pthread_cond_t full;
pthread_cond_t empty;
void* producer(void* arg) {
int item = 1;
while (produced_count < MAX_ITEMS) {
pthread_mutex_lock(&mutex);
while (((in + 1) % BUFFER_SIZE) == out) {
pthread_cond_wait(&empty, &mutex);
}
buffer[in] = item;
printf("Produced: %d</p><p>", item);
item++;
in = (in + 1) % BUFFER_SIZE;
produced_count++;
pthread_cond_signal(&full);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
void* consumer(void* arg) {
while (consumed_count < MAX_ITEMS) {
pthread_mutex_lock(&mutex);
while (in == out) {
pthread_cond_wait(&full, &mutex);
}
int item = buffer[out];
printf("Consumed: %d</p><p>", item);
out = (out + 1) % BUFFER_SIZE;
consumed_count++;
pthread_cond_signal(&empty);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
int main() {
pthread_t producerThread, consumerThread;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&full, NULL);
pthread_cond_init(&empty, NULL);
pthread_create(&producerThread, NULL, producer, NULL);
pthread_create(&consumerThread, NULL, consumer, NULL);
pthread_join(producerThread, NULL);
pthread_join(consumerThread, NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&full);
pthread_cond_destroy(&empty);
return 0;
}
Dalam contoh ini, penyelesaian penimbal terhad kepada masalah pengeluar-pengguna dilaksanakan menggunakan kunci mutex dan pembolehubah keadaan. Urutan pengeluar menjana item dan menambahkannya pada penimbal, manakala utas pengguna mendapatkan dan menggunakan item daripada penimbal. Mutex memastikan eksklusiviti bersama apabila mengakses penimbal, dan pembolehubah keadaan (penuh dan kosong) menyelaraskan rangkaian pengeluar dan pengguna. Menambahkan syarat penamatan untuk mengehadkan bilangan item yang dijana dan digunakan.
Produced: 1 Produced: 2 Produced: 3 Produced: 4 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Produced: 5 Consumed: 5
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define BUFFER_SIZE 5
#define MAX_ITEMS 20
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int produced_count = 0;
int consumed_count = 0;
sem_t mutex;
sem_t full;
sem_t empty;
void* producer(void* arg) {
int item = 1;
while (produced_count < MAX_ITEMS) {
sem_wait(&empty);
sem_wait(&mutex);
buffer[in] = item;
printf("Produced: %d</p><p>", item);
item++;
in = (in + 1) % BUFFER_SIZE;
produced_count++;
sem_post(&mutex);
sem_post(&full);
}
pthread_exit(NULL);
}
void* consumer(void* arg) {
while (consumed_count < MAX_ITEMS) {
sem_wait(&full);
sem_wait(&mutex);
int item = buffer[out];
printf("Consumed: %d</p><p>", item);
out = (out + 1) % BUFFER_SIZE;
consumed_count++;
sem_post(&mutex);
sem_post(&empty);
}
pthread_exit(NULL);
}
int main() {
pthread_t producerThread, consumerThread;
sem_init(&mutex, 0, 1);
sem_init(&full, 0, 0);
sem_init(&empty, 0, BUFFER_SIZE);
pthread_create(&producerThread, NULL, producer, NULL);
pthread_create(&consumerThread, NULL, consumer, NULL);
pthread_join(producerThread, NULL);
pthread_join(consumerThread, NULL);
sem_destroy(&mutex);
sem_destroy(&full);
sem_destroy(&empty);
return 0;
}
Dalam contoh ini, penyelesaian penimbal terhad kepada masalah pengeluar-pengguna dilaksanakan menggunakan semafor. Semaphore digunakan untuk mengawal akses kepada penimbal dan menyegerakkan benang pengeluar dan pengguna. Semaphore Mutex memastikan akses yang saling eksklusif, semaphore penuh menjejaki bilangan item dalam penimbal, dan semafor kosong menjejaki bilangan slot kosong yang tersedia. Menambah syarat penamatan untuk mengehadkan bilangan item yang dihasilkan dan digunakan.
Produced: 1 Consumed: 1 Produced: 2 Consumed: 2 Produced: 3 Consumed: 3 Produced: 4 Consumed: 4 Produced: 5 Consumed: 5
生产者-消费者问题是并发编程中的一个重要挑战。通过理解问题并采用适当的同步技术，如互斥锁、条件变量、信号量或监视器，在C编程语言中可以开发出健壮的解决方案。这些解决方案使生产者和消费者能够和谐地共同工作，在并发系统中确保高效的数据生成和消费。
Atas ialah kandungan terperinci Terjemahan masalah pengeluar-pengguna dalam bahasa C. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
