Race condition facts for kids

Kids Encyclopedia Facts

A race condition or race hazard happens when a computer program or electronic system tries to do several things at the same time, but the order in which they finish is unexpected. This can lead to strange or wrong results. It's like a "race" between different parts of the system to see which one finishes first. If the wrong one wins the race, it can cause a problem, like a software bug.

The idea of a "race condition" has been around since at least 1954. It's a common issue in logic circuits (like those in your phone or computer) and in computer programs that do many things at once.

Top - 0-9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

In electronics

Imagine a logic gate in an electronic circuit. It takes signals from different places and combines them. If these signals come from the same source but travel along slightly different paths, they might arrive at the gate at different times.

For example, if a signal `A` and its opposite `not A` (meaning `A` is true, `not A` is false, or vice versa) are supposed to go into an "AND" gate, the gate should never output a "true" signal. This is because `A` and `not A` can't both be true at the same time.

However, if `A` changes from false to true, and it takes a tiny bit longer for the `not A` signal to change (from true to false), there might be a very brief moment when both inputs are "true." During this tiny moment, the gate's output would also be "true," which is wrong! This brief, unwanted signal is called a glitch. If this glitch affects other parts of the circuit that remember things, it can cause the whole system to go wrong.

What are critical and non-critical races?

A critical race condition in electronics means that the final state of the circuit depends on the exact order that things happen. If the order is wrong, the circuit ends up in a bad state.

A non-critical race condition means that even if things happen in a different order, the circuit still ends up in the correct final state. It might just take a slightly different path to get there.

How to avoid race conditions in electronics

Engineers use special design methods, like Karnaugh maps, to find and fix race conditions before they build the circuits. Sometimes, they add extra parts to the circuit to make sure these races don't cause problems.

In software

A race condition can also happen in computer programs. This occurs when a program has different parts of its code running at the same time. If these parts finish in an unexpected order, it can lead to software bugs. This can even cause security problems between different programs.

When different parts of a program (called "threads" or "processes") need to use the same shared information, they should take turns. If they don't, and try to change the same information at the same time, the information can get mixed up or corrupted. This is a common type of race condition called a data race.

It's very hard to find and fix race conditions in software. This is because they don't always happen. They depend on the exact timing of events, which can change every time the program runs. A bug that disappears when you try to find it is sometimes called a "Heisenbug" (like the "Heisenberg Uncertainty Principle" in physics). Because they are so tricky, it's best to design software carefully to avoid race conditions from the start.

A simple example

Let's say two parts of a program (Thread 1 and Thread 2) both want to add 1 to a global number. The number starts at 0.

Ideally, this is what should happen:

Thread 1	Thread 2		Number
			0
read value		←	0
add 1			0
write back		→	1
	read value	←	1
	add 1		1
	write back	→	2

The final number is 2, which is correct.

But if they run at the same time without taking turns, a race condition can happen:

Thread 1	Thread 2		Number
			0
read value		←	0
	read value	←	0
add 1			0
	add 1		0
write back		→	1
	write back	→	1

In this case, the final number is 1, not 2! This happened because both threads read the number (0) at the same time. Then, both added 1 to their own copy of 0, getting 1. Finally, both wrote their 1 back, so the number ended up as 1. They didn't take turns, so the shared number got corrupted.

Data races

A data race is a specific type of race condition. It happens when two parts of a program try to access the same memory location at the same time, and at least one of them is trying to write to it. This can be dangerous because the memory might end up with a jumbled, meaningless value.

Some programming languages, like C++ and Java, have rules about data races. In C++, a data race can cause "undefined behavior," meaning the program could crash or do something completely unexpected. In Java, a data race might cause wrong results, but it usually won't crash the program.

Computer security

Race conditions can be a big problem for computer security. If an attacker can cause a race condition, they might be able to make a system malfunction. This could lead to a denial of service (where the system stops working) or even privilege escalation (where the attacker gains more control than they should have).

One common security race condition is called "time-of-check to time-of-use" (TOCTTOU). This happens when a program checks something (like if you have permission to do something), but then the situation changes before the program actually uses that information. An attacker could quickly change the situation between the check and the use, tricking the program.

Interestingly, race conditions are also used on purpose to create hardware random number generators and special security features called physically unclonable functions (PUFs). These use the tiny, random differences in how electronic circuits are made to create unique "fingerprints" for devices.

File systems

Race conditions can also happen when different programs try to use or change files on a computer's file system at the same time. This can corrupt data or cause other problems. A common solution is File locking, which makes sure only one program can access a file at a time.

Another file system race condition happens when programs unexpectedly use up shared resources like disk space or memory. If a program isn't designed to handle this, it might crash or behave strangely. For example, the Mars Rover "Spirit" almost stopped working because a file system problem used up all its memory. To prevent this, programs should try to reserve all the resources they need before starting a task.

Networking

In computer networks, race conditions can occur when information takes time to travel. For example, in a chat network, if two users on different servers try to create a channel with the same name at the exact same time, both servers might think they created it first. This is because the signal from one server hasn't reached the other yet. Modern chat networks have mostly fixed this problem.

Life-critical systems

When race conditions happen in systems that are important for safety, the results can be very serious.

The Therac-25 radiation therapy machine had race conditions in its software. These flaws led to the deaths of at least three patients and injuries to several others.
A race condition in the energy management system used by FirstEnergy Corp (a power company) contributed to the 2003 North America blackout. When three power lines tripped at the same time, the software bug prevented alarms from reaching technicians. This delayed their response and made the blackout worse. The company later fixed this hidden error.

Tools to find race conditions

Many software tools help programmers find race conditions. These tools can either look at the code without running it (static analysis) or watch the program as it runs (dynamic analysis). Some popular tools include Intel Inspector, ThreadSanitizer, and Helgrind. There are also special tests, like DataRaceBench, to check how well these tools work.

In other areas

Race conditions aren't just in computers!

In human-computer interaction design, a race condition can happen if a system does something unexpected while a user is in the middle of another action. For example, accidentally answering a call on a smartphone while trying to do something else.
In UK railway signalling, there used to be a rule where if a train stopped at a signal, the fireman had to walk to the signal box to tell the signalman the train was there. In one case, at Winwick in 1934, an accident happened because the signalman let another train through before the fireman arrived. Modern radio communication has fixed this race condition.
Even in the brain, scientists are finding that race conditions can occur. For example, there's a race between the brain signals that tell you to move and the signals that tell you to stop that movement.