🚀 go-pugleaf

"Vladimir Afanasyev" <avv@systema.kiev.ua> wrote in message
news:41eea799$1@newsgroups.borland.com...

> It is not exactly because it's not clear from task when and
> how threads will work with variable.
>
> For example both threads access to variable asynchronous. Look.
>
> One thread modyfyes variable in 10:00 and 10:05.
>
> Another thread may read in 9:58, 10:02, 10:07.

You can't rely on that to provide safe access.  For instance, say the
reading thread begins reading the variable, then the OS task-switches to the
writing thread before the reading thread can finish reading the variable.
The writing thread alters the variable, then the OS task-switches back to
the reading thread, which then finishes reading the variable.  The reading
thread now has a corrupt value because it read bytes from two different time
periods.

That is why you should always synchronize access to shared data - because
you do not have control over when a thread will try to access that shared
variable.  A thread that wants to alter the variable should be made to wait
until after any reading threads have completely read all of the unaltered
bytes in full.

> If this threads doesn't know exactly when data was changed
> it may read it in any time or it must carefully track for changes.
> Critical sections doesn't help for tracking changes (or it must
> be called continuously).

You are missing the point.  In order for a thread to know that the data was
changed, thus needing to re-read teh new value, the thread still has to
access the variable in general.  That general access must be protected,
regardless of the reason for the access.

> I only say that it is not important to enter in critical section if
> unknown when changes were.

Of course it is important.

> Reading thread can enter before first writing or after but really reading
> thread must all time "listen" variable via critical section or semaphor.

Using a critical section or semaphor is completely meaningless unless all
involved thread use it.  You can't have just the reading thread only enter
the critical section and not have the writing thread as well.  The data is
will not be protected at all unless the writing thread enters the critical
section as well.


Gambit