a non-blocking algorithm
Think about what goes wrong when one worker on a shared task suddenly takes a long coffee break. In a blocking design — one built on locks — if that worker was holding the lock, everyone else freezes until they come back. A non-blocking design is one where no thread's pause can ever freeze the others. That is the umbrella term for the whole family of techniques in this field.
Precisely: an algorithm is non-blocking if the suspension or failure of any thread cannot prevent other threads from making progress. There are no critical sections protected by a lock; instead, threads coordinate using atomic read-modify-write instructions like compare-and-swap. Non-blocking is exactly the union of the three progress classes you have met: wait-free, lock-free, and obstruction-free are all non-blocking, in decreasing order of strength. The opposite is a blocking algorithm — anything where a thread can be made to wait on another thread, which is what mutexes, condition variables, and semaphores do.
The motivation is robustness as much as speed. Because no thread can hold a resource that others must wait for, non-blocking algorithms are immune to several disasters that haunt lock-based code: a thread killed mid-update cannot deadlock the system, priority inversion (a low-priority thread holding a lock a high-priority thread needs) cannot occur, and there is no convoy where threads pile up behind one slow lock-holder. The price is that non-blocking algorithms are far harder to design, prove correct, and test — which is why most programs still use locks for most things.
Blocking: pthread_mutex_lock(&m); /* if holder sleeps, you wait */ x = x + 1; pthread_mutex_unlock(&m); Non-blocking: do { old = x; } while (!CAS(&x, old, old + 1)); /* holder sleeping cannot stop you — you just keep trying */
The blocking version stalls if the lock-holder is paused; the non-blocking version never depends on any one thread waking up.
Non-blocking is the umbrella; wait-free, lock-free, and obstruction-free are its three named strengths. Non-blocking removes deadlock and priority inversion but does not remove the need for safe memory reclamation.