Threads share memory, and that is where the trouble starts. A data race happens when two threads access the same variable at the same time, at least one of them writes, and nothing orders the two accesses. In C++ a data race is undefined behavior: not just a wrong total, but a program the compiler is allowed to break in any way.
The classic example is count++ on a plain int from two threads. It is a load, an add and a store, and if both threads load before either stores, one increment is lost. Reading the same variable from many threads is fine; so is writing a variable only one thread ever touches. std::atomic<T> makes each operation on the variable indivisible, and a mutex makes a whole block exclusive.
About this unit: here you reason about threads on paper. You enumerate interleavings yourself, spot races in code, and write atomic code whose logic the tests check on one thread. The next unit, Running threads, runs real std::thread code in a simulator that switches between threads under many schedules.
The same increment, racy and atomic.