The producer-consumer problem described above is a specific example of a more general situation known as the critical section problem.This is a very common occurrence among cooperating processes, so lets look at some ways in which this is done, as well as some classic problems in this area. Obviously the solution is to only allow one process at a time to manipulate the value "counter".( or wrong! :-) ) Race conditions are also very difficult to reproduce. Note that race conditions are notoriously difficult to identify and debug, because by their very nature they only occur on rare occasions, and only when the timing is just exactly right.Exercise: What would be the resulting value of counter if the order of statements T4 and T5 were reversed? ( What should the value of counter be after one producer and one consumer, assuming the original value was 5? ).If the instructions from the two processes get interleaved, there could be serious problems, such as illustrated by the following: But, you might say, "Each of those are single instructions - How can they get interrupted halfway through?" The answer is that although they are single instructions in C++, they are actually three steps each at the hardware level: (1) Fetch counter from memory into a register, (2) increment or decrement the register, and (3) Store the new value of counter back to memory.
Geting semaphor value update#
If one process gets part way through making the update and then the other process butts in, the value of counter can get left in an incorrect state. The particular problem above comes from the producer executing "counter++" at the same time the consumer is executing "counter-".( Bank balance example discussed in class.
Geting semaphor value code#
In this condition a piece of code may or may not work correctly, depending on which of two simultaneous processes executes first, and more importantly if one of the processes gets interrupted such that the other process runs between important steps of the first process.
We could try to overcome this deficiency by introducing a counter variable, as shown in the following code segments:.One slot is unavailable because there always has to be a gap between the producer and the consumer. The only problem with the above code is that the maximum number of items which can be placed into the buffer is BUFFER_SIZE - 1.* Wait for an item to become available */ * And then store the item and repeat the loop. While( ( ( in + 1 ) % BUFFER_SIZE ) = out ) * Produce an item and store it in nextProduced */ Recall that back in Chapter 3 we looked at cooperating processes ( those that can effect or be effected by other simultaneously running processes ), and as an example, we used the producer-consumer cooperating processes:.Think about it, and don't just accept them at face value. As you read each of the algorithms below, you need to satisfy yourself that they do indeed work under all conditions. Warning: This chapter requires some heavy thought. Abraham Silberschatz, Greg Gagne, and Peter Baer Galvin, "Operating System Concepts, Ninth Edition ", Chapter 5.Operating Systems: Process Synchronization
0 kommentar(er)
