In PostgreSQL, interlocked functions refer to operations that ensure atomicity and thread safety when accessing or modifying data. These functions provide a way to perform operations that cannot be interrupted or corrupted by other concurrent threads or processes.

Some commonly used interlocked functions in PostgreSQL include:

1. Atomic Compare-and-Swap (CAS): The `pg_atomic_compare_exchange_*` functions allow atomic compare-and-swap operations. They compare the value of a shared variable with an expected value and update it if the comparison succeeds. This ensures that the variable is modified atomically without interference from other threads.

2. Atomic Fetch-and-Add (FAA): The `pg_atomic_fetch_add_*` functions perform atomic fetch-and-add operations. They atomically read the value of a shared variable, increment it by a specified amount, and return the original value. This ensures that multiple threads can safely increment a shared variable without race conditions.

3. Spinlocks: PostgreSQL provides spinlock functions (`pg_atomic_spinlock_*`) that allow threads to acquire and release spinlocks. Spinlocks ensure exclusive access to critical sections of code, protecting them from concurrent execution. Spinlocks use busy-waiting, where a thread repeatedly checks for the lock's availability, ensuring atomicity and thread safety.

These interlocked functions are essential in multi-threaded or multi-process environments to prevent data corruption, race conditions, and other concurrency-related issues. They help ensure that operations on shared data are performed atomically and consistently across threads or processes.