Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

Zadanie: Zrobić kod do sterowania dwoma semaforami jednoelementowymi z klawiatury: 1 –…

  1. User

    Zadanie: Zrobić kod do sterowania dwoma semaforami jednoelementowymi z klawiatury: 1 – zajęcia semafora 1 q – zwolnienie semafora 1 2 – zajęcie semafora 2 w – zwolnienie semafora 2 Wystarczy uruchomić dwie instancje tego samego programu

    1. Pokazać blokowanie dostępu do zasobu dla instancji 2 przez instancję 1, a następnie uwolnienie dostępu przez zwolnienie zasobu w instancji 1
    2. Pokazać zakleszczenie w jezyku c
  2. Assistant

    Zaprojektowanie programu, który operuje dwoma semaforami sterowanymi klawiaturą w języku C oraz pokazywanie blokowania i zakleszczenia, wymaga zrozumienia zarówno współbieżności jak i mechanizmów synchronizacyjnych jakimi są semafory. Poniższym przykładem chciałbym pokazać podstawową implementację. Zakładam, że współdzielenie semaforów między instancjami programu może być realizowane za pomocą semaforów nazwanych.

    Krok 1: Implementacja sterowania semaforami

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    #include <semaphore.h>
    #include <errno.h>
    
    #define SEMAPHORE_1 "/semaphore1"
    #define SEMAPHORE_2 "/semaphore2"
    
    int main() {
        sem_t *sem1 = sem_open(SEMAPHORE_1, O_CREAT, 0644, 1);
        sem_t *sem2 = sem_open(SEMAPHORE_2, O_CREAT, 0644, 1);
        if (sem1 == SEM_FAILED || sem2 == SEM_FAILED) {
            perror("sem_open failed");
            exit(EXIT_FAILURE);
        }
    
        char command;
        while (1) {
            command = getchar();
    
            switch (command) {
                case '1':
                    if (sem_wait(sem1) == 0) {
                        printf("Semafor 1 zajęty.\n");
                    } else {
                        perror("sem_wait");
                    }
                    break;
                case 'q':
                    if (sem_post(sem1) == 0) {
                        printf("Semafor 1 zwolniony.\n");
                    } else {
                        perror("sem_post");
                    }
                    break;
                case '2':
                    if (sem_wait(sem2) == 0) {
                        printf("Semafor 2 zajęty.\n");
                    } else {
                        perror("sem_wait");
                    }
                    break;
                case 'w':
                    if (sem_post(sem2) == 0) {
                        printf("Semafor 2 zwolniony.\n");
                    } else {
                        perror("sem_post");
                    }
                    break;
                case 'e': // Wyjście
                    goto exit;
                default:
                    printf("Nieznane polecenie.\n");
            }
        }
    
    exit:
        sem_close(sem1);
        sem_close(sem2);
        sem_unlink(SEMAPHORE_1);
        sem_unlink(SEMAPHORE_2);
        return 0;
    }
    

    Program pozwala na zajęcie i zwolnienie semafora 1 (przez wciskanie "1" lub "q") i semafora 2 ("2" lub "w").

    Krok 2: Demonstracja blokady

    Aby zilustrować blokowanie dostępu do zasobu:

    1. Uruchom dwie instancje programu.
    2. W pierwszej zaznacz semafor 1 ("1").
    3. Próbuj zaznaczyć semafor 1 w drugiej instancji. Zauważ, że program czeka, aż semafor zostanie zwolniony.
    4. Zwróć semafor 1 w pierwszej instancji ("q"). Teraz druga instancja może zaznaczyć semafor 1.

    Krok 3: Demonstracja zakleszczenia

    Zakleszczenie może wystąpić, gdy każda z instancji zajmie jeden semafor i będzie próbowała zająć semafor, który jest już zajęty przez inną instancję.

    1. Instancja 1 zajmuje semafor 1 ("1").
    2. Instancja 2 zajmuje semafor 2 ("2").
    3. Instancja 1 próbuje zająć semafor 2 ("2"), lecz jest on zajęty przez instancję 2.
    4. Instancja 2 próbuje zająć semafor 1 ("1"), również jest on zajęty przez instancję 1.

    Obie instancje są zablokowane oczekując na zasoby, które są trzymane przez inną instancję, co ilustruje klasyczny przypadek zakleszczenia.

    Warto pamiętać, że zakleszczenie jest skomplikowanym problemem w systemach współbieżnych i wymaga zaawansowanych strategii, aby go unikać lub rozwiązywać.

  3. User

    bez case

  4. Assistant

    Jeśli preferujesz unikająć użycia konstrukcji switch-case, możemy zmodyfikować powyższy program, aby używał instrukcji if-else. Oto, jak by to wyglądało:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    #include <semaphore.h>
    #include <errno.h>
    
    #define SEMAPHORE_1 "/semaphore1"
    #define SEMAPHORE_2 "/semaphore2"
    
    int main() {
        sem_t *sem1 = sem_open(SEMAPHORE_1, O_CREAT, 0644, 1); // Tworzenie semafora 1
        sem_t *sem2 = sem_open(SEMAPHORE_2, O_CREAT, 0644, 1); // Tworzenie semafora 2
        if (sem1 == SEM_FAILED || sem2 == SEM_FAILED) { // Obsługa błędów
            perror("sem_open failed");
            exit(EXIT_FAILURE);
        }
    
        char command;
        while (1) {
            command = getchar(); // Czytanie polecenia
            getchar(); // Przechwycenie znaku nowej linii
    
            if (command == '1') { // Zajęcie semafora 1
                if (sem_wait(sem1) == 0) {
                    printf("Semafor 1 zajęty.\n");
                } else {
                    perror("sem_wait");
                }
            } else if (command == 'q') { // Zwolnienie semafora 1
                if (sem_post(sem1) == 0) {
                    printf("Semafor 1 zwolniony.\n");
                } else {
                    perror("sem_post");
                }
            } else if (command == '2') { // Zajęcie semafora 2
                if (sem_wait(sem2) == 0) {
                    printf("Semafor 2 zajęty.\n");
                } else {
                    perror("sem_wait");
                }
            } else if (command == 'w') { // Zwolnienie semafora 2
                if (sem_post(sem2) == 0) {
                    printf("Semafor 2 zwolniony.\n");
                } else {
                    perror("sem_post");
                }
            } else if (command == 'e') { // Wyjście
                break;
            } else {
                printf("Nieznane polecenie.\n");
            }
        }
    
        // Porządki
        sem_close(sem1);
        sem_close(sem2);
        sem_unlink(SEMAPHORE_1);
        sem_unlink(SEMAPHORE_2);
        return 0;
    }
    

    Ten kod wykonuje te same operacje co poprzedni, ale zastąpiliśmy switch-case serią if-else do obsługi różnych poleceń. Sprawdzi to zadanie i pozwala na sterowanie dwoma semaforami za pomocą wejścia z klawiatury. Pamiętaj, że tej konkretniej implementacji używam tylko dla demonstracji obsługi semaforów i działania z blokowaniem oraz unikania zakleszczeń w prostym środowisku. W rzeczywistych projektach konieczne mogą być bardziej zaawansowane techniki zarządzania współbieżnością.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.