We have discussed this in other threads but in essence the shared data problem can occur whenever two pieces of code share common data and one piece of code can interrupt the other while it is in the middle of using the data. The result is at least corrupt data and often worse.

The most common form of code interrupting other code is of course in interrupt routines . Anytime a code fragment reads a multibyte value set by and ISR or writes a multibyte value used by an ISR, it is possible for the ISR to occur part way through the read or write and either corrupt the value being read or use a partly set value. This is the shared data problem. To avoid it the read or write operation must not be interruptable. This is called an atomic operation and the code fragment where the problem might occur is known as a critical section.

People think provided the use unsigned chars they will not get the problem. This is not the case for several reasons:

1. Compilers often promote chars to ints internally.
2. The operation needs to be atomic so if you read a char, operate on it then save back where you got it from, the operation is not atomic.
3. The problem can apply not only to the data but to shared pointers.

A common solution is to disable interrupts just before the critical section and enable them just after.

Ian