The readers-writers problem relates to an object such as a file that is shared between multiple processes. Some of these processes are readers, i.e. they only want to read the data from the object, and some of the processes are writers, i.e. they want to write into the object. Without proper synchronization, a reader may prematurely return data it has not yet fully processed, or miss changes made by a writer. In computer science, the readers-writers problem is the simplest form of concurrency control. It can be stated as follows: given an object on which several processes may read concurrently and several more may write concurrently, determine if any process could corrupt the object's state. It is important to note that the readers-writers problem does not specify how the processes communicate with each other. In other words, the problem assumes that the processes have no way of knowing who else is reading or writing to the object at any given time. This means that there is no way for them to cooperate in order to avoid conflict. For example, a first process that wants to write to the object might do so immediately after reading data from it. However, a second process that wants to read the object later could see the first process' change even though its own request was denied because the second process had not yet finished reading. There are many solutions to this problem. One solution is to use a lock mechanism when accessing the object.