ISU+Ov6


 * Øvelse 1_1**

I Øvelsen skal vi opbygge et parkerings ssystem hvor flere biler kan forespørge om de må køre ind, er der plads i garagen kan bilen køre ind og døren til garagen lukker så igen. Ligeledes skal bilen kunne køre ud. I første del af opgaven starter vi med at lave koden således at en bil kan køre ind og ud, den skal stadig forespørge om dette er muligt. Vi løser problemet med multithreading. Vi oprette en lock, denne tages når man går ind i tråden. ved hjælp af conditionels kan man så gå fra den ene tråd over i den ande, altså man lægger den ene til at sove imens at den anden arbejder i locken. code
 * 1) include
 * 2) include 
 * 3) include 

using namespace std;

bool carWaiting = false; bool doorOpen = true; bool openParkingSpace; bool closeParkingSpace; int amountOfCarsInGarage;

const int thread_number = 1; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t entry = PTHREAD_COND_INITIALIZER;

void *carDriverThread(void* arg) { void driverToParking(void* );//ankommer til parkering

cout << "ankommer til parkering" << endl; sleep(3); pthread_mutex_lock(&lock);

carWaiting = true;

cout << "bilen venter" << endl; sleep(2);

pthread_cond_signal(&entry);

while(!doorOpen);

pthread_cond_wait(&entry, &lock);//hopper til næste tråd, condWait amountOfCarsInGarage++; cout << "bilen køre ind i p-kælderen" << endl; sleep(5); carWaiting = false; cout << "der er ingen biler i kø" << endl; pthread_cond_signal(&entry); pthread_mutex_unlock(&lock);//Unlock mutex, hopper til sidste condWait i parkingSpaceThread

sleep(10);

cout << "bilen køre ud igen" << endl;

}

void *parkingSpaceThread(void* arg ) { pthread_mutex_lock(&lock);

while(carWaiting = false) cout << "der er ikke nogen biler i køen" << endl;

pthread_cond_wait(&entry, &lock);//modtager tråd fra CarDriverThread cout << "hvis der er en bil der vænter" << endl;

cout << "døren er åben og der er "<< amountOfCarsInGarage << " biler i garagen" << endl; doorOpen = true;

pthread_cond_signal(&entry); while(carWaiting) pthread_cond_wait(&entry, &lock);//hopper tilbage til conWait i CarDriverThread // closeParkingSpace;//lukker parkering efter unlock i CarDriverThread doorOpen = false; cout << "døren er lukket og der er " << amountOfCarsInGarage << " biler i garagen" << endl; pthread_mutex_unlock(&lock);//frigiver mutex }

int main { pthread_t car, park;

pthread_create(&car, NULL, carDriverThread, NULL); pthread_create(&park, NULL, parkingSpaceThread, NULL);

pthread_join(car, NULL); pthread_join(park, NULL);

return 0; }

code

Udprint: ankommer til parkering bilen venter hvis der er en bil der vænter døren er åben og der er 0 biler i garagen bilen køre ind i p-kælderen der er ingen biler i kø døren er lukket og der er1 biler i garagen bilen køre ud igen


 * Øvelse1_2**

I denne del af øvelsen skal vi udvide del 1.1 til at fungerer med flere biler dette gøres for at undgå eventuelle deadlocks hvilket kan fremkomme hvis en thread sætter vores kondision true hvorefter at dan anden thread sætter konditonen false.

til dette ændres kø fra at være en bolsk variable der enten kan være true eller false til at være en int der kan arbejde med flere biler. nede i selve koden bliver vores true værdier sat til at inkrementere vores kø variabler ligeledes sættes vores false til at dekrementerer vores kø tæller.

nede i vores while løkker sættes vores kondition til at arbejde med værdien når køen er på nul biler for den første while og den anden while sættes til at loope når køen er støre end nul.

code void* carController(void* threadid) {   int *id = reinterpret_cast(threadid);

printf("  %d: ankommer til pkælderen\n", id); pthread_mutex_lock(&mutexEntry);

carEntryWait++; pthread_cond_signal(&entry);

while(!entryPortOpened) pthread_cond_wait(&entry, &mutexEntry);

printf("  %d: kører ind i garagen\n", id);

carEntryWait--; pthread_cond_signal(&entry); pthread_mutex_unlock(&mutexEntry);

sleep(3); //Vente tid.. Denne kan ændres efter ønske.

pthread_mutex_lock(&mutexExit); carExitWait++; pthread_cond_signal(&exit);

while(!exitPortOpened) {       pthread_cond_wait(&exit, &mutexExit); }   printf("   %d: kører ud\n", id);

carExitWait--; pthread_cond_signal(&exit); pthread_mutex_unlock(&mutexExit); }

void* entryController(void* threadid) {   while(1) {       pthread_mutex_lock(&mutexEntry); while(carEntryWait == 0) pthread_cond_wait(&entry, &mutexEntry);

printf("åbner indgangen \n");

entryPortOpened = true; pthread_cond_signal(&entry);

while(entryPortOpened) pthread_cond_wait(&entry, &mutexEntry);

printf("Lukker indgangen \n"); entryPortOpened = false; pthread_mutex_unlock(&mutexEntry); } }

void* exitController(void* threadid) {   while(1) {       pthread_mutex_lock(&mutexExit); while(carExitWait == 0) pthread_cond_wait(&exit, &mutexExit);

cout << "åbner udgangen" << endl;

exitPortOpened = true; pthread_cond_signal(&exit);

while(carExitWait > 0) pthread_cond_wait(&exit, &mutexExit);

cout << "lukker udgangen" << endl;

pthread_mutex_unlock(&mutexExit); } }

code

code 1: ankommer til pkælderen 0: ankommer til pkælderen åbner indgangen 2: ankommer til pkælderen 2: kører ind i garagen 3: ankommer til pkælderen 1: kører ind i garagen 3: kører ind i garagen 0: kører ind i garagen åbner udgangen 3: kører ud  1: kører ud   0: kører ud   2: kører ud lukker udgangen code
 * udskrift på skærm**



vi har i øvelsen læt at man gennem signaler kan få forskellige threads til at aktivere hinnandens ellementer, dette giver os fordele til at udvikele mere komplekse strukture i vores kode.
 * Konklusion**

[] [] []