---
name: "ck_spinlock"
section: "3"
platform: "linux"
package: "libck-dev"
version: "0.7.2-6"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/ck_spinlock"
---

# ck\_spinlock(3)

spinlock implementations

## NAME

**ck\_spinlock\_init**, **ck\_spinlock\_lock**, **ck\_spinlock\_unlock**, **ck\_spinlock\_locked**, **ck\_spinlock\_trylock**, **ck\_spinlock\_anderson\_init**, **ck\_spinlock\_anderson\_locked**, **ck\_spinlock\_anderson\_lock**, **ck\_spinlock\_anderson\_unlock**, **ck\_spinlock\_cas\_init**, **ck\_spinlock\_cas\_locked**, **ck\_spinlock\_cas\_lock**, **ck\_spinlock\_cas\_lock\_eb**, **ck\_spinlock\_cas\_trylock**, **ck\_spinlock\_cas\_unlock**, **ck\_spinlock\_clh\_init**, **ck\_spinlock\_clh\_locked**, **ck\_spinlock\_clh\_lock**, **ck\_spinlock\_clh\_unlock**, **ck\_spinlock\_dec\_init**, **ck\_spinlock\_dec\_locked**, **ck\_spinlock\_dec\_lock**, **ck\_spinlock\_dec\_lock\_eb**, **ck\_spinlock\_dec\_trylock**, **ck\_spinlock\_dec\_unlock**, **ck\_spinlock\_fas\_init**, **ck\_spinlock\_fas\_lock**, **ck\_spinlock\_fas\_lock\_eb**, **ck\_spinlock\_fas\_locked**, **ck\_spinlock\_fas\_trylock**, **ck\_spinlock\_fas\_unlock**, **ck\_spinlock\_hclh\_init**, **ck\_spinlock\_hclh\_locked**, **ck\_spinlock\_hclh\_lock**, **ck\_spinlock\_hclh\_unlock**, **ck\_spinlock\_mcs\_init**, **ck\_spinlock\_mcs\_locked**, **ck\_spinlock\_mcs\_lock**, **ck\_spinlock\_mcs\_trylock**, **ck\_spinlock\_mcs\_unlock**, **ck\_spinlock\_ticket\_init**, **ck\_spinlock\_ticket\_locked**, **ck\_spinlock\_ticket\_lock**, **ck\_spinlock\_ticket\_lock\_pb**, **ck\_spinlock\_ticket\_trylock**, **ck\_spinlock\_ticket\_unlock** – spinlock implementations

## LIBRARY

Concurrency Kit (libck, -lck)

## SYNOPSIS

**#include \<ck\_spinlock.h\>**

ck\_spinlock\_t spinlock = CK\_SPINLOCK\_INITIALIZER;

*void*\

**ck\_spinlock\_init**(*ck\_spinlock\_t \*lock*);

*void*\

**ck\_spinlock\_lock**(*ck\_spinlock\_t \*lock*);

*void*\

**ck\_spinlock\_unlock**(*ck\_spinlock\_t \*lock*);

*bool*\

**ck\_spinlock\_locked**(*ck\_spinlock\_t \*lock*);

*bool*\

**ck\_spinlock\_trylock**(*ck\_spinlock\_t \*lock*);

*void*\

**ck\_spinlock\_anderson\_init**(*ck\_spinlock\_anderson\_t \*lock*, *ck\_spinlock\_anderson\_thread\_t \*slots*, *unsigned int count*);

*bool*\

**ck\_spinlock\_anderson\_locked**(*ck\_spinlock\_anderson\_t \*lock*);

*void*\

**ck\_spinlock\_anderson\_lock**(*ck\_spinlock\_anderson\_t \*lock*, *ck\_spinlock\_anderson\_thread\_t \*\*slot*);

*void*\

**ck\_spinlock\_anderson\_unlock**(*ck\_spinlock\_anderson\_t \*lock*, *ck\_spinlock\_anderson\_thread\_t \*slot*);

ck\_spinlock\_cas\_t spinlock = CK\_SPINLOCK\_CAS\_INITIALIZER;

*void*\

**ck\_spinlock\_cas\_init**(*ck\_spinlock\_cas\_t \*lock*);

*bool*\

**ck\_spinlock\_cas\_locked**(*ck\_spinlock\_cas\_t \*lock*);

*void*\

**ck\_spinlock\_cas\_lock**(*ck\_spinlock\_cas\_t \*lock*);

*void*\

**ck\_spinlock\_cas\_lock\_eb**(*ck\_spinlock\_cas\_t \*lock*);

*bool*\

**ck\_spinlock\_cas\_trylock**(*ck\_spinlock\_cas\_t \*lock*);

*void*\

**ck\_spinlock\_cas\_unlock**(*ck\_spinlock\_cas\_t \*lock*);

*void*\

**ck\_spinlock\_clh\_init**(*ck\_spinlock\_clh\_t \*\*lock*, *ck\_spinlock\_clh\_t \*unowned*);

*bool*\

**ck\_spinlock\_clh\_locked**(*ck\_spinlock\_clh\_t \*\*lock*);

*void*\

**ck\_spinlock\_clh\_lock**(*ck\_spinlock\_clh\_t \*\*lock*, *ck\_spinlock\_clh\_t \*node*);

*void*\

**ck\_spinlock\_clh\_unlock**(*ck\_spinlock\_clh\_t \*\*node*);

ck\_spinlock\_dec\_t spinlock = CK\_SPINLOCK\_DEC\_INITIALIZER;

*void*\

**ck\_spinlock\_dec\_init**(*ck\_spinlock\_dec\_t \*lock*);

*bool*\

**ck\_spinlock\_dec\_locked**(*ck\_spinlock\_dec\_t \*lock*);

*void*\

**ck\_spinlock\_dec\_lock**(*ck\_spinlock\_dec\_t \*lock*);

*void*\

**ck\_spinlock\_dec\_lock\_eb**(*ck\_spinlock\_dec\_t \*lock*);

*bool*\

**ck\_spinlock\_dec\_trylock**(*ck\_spinlock\_dec\_t \*lock*);

*void*\

**ck\_spinlock\_dec\_unlock**(*ck\_spinlock\_dec\_t \*lock*);

ck\_spinlock\_fas\_t spinlock = CK\_SPINLOCK\_FAS\_INITIALIZER;

*void*\

**ck\_spinlock\_fas\_init**(*ck\_spinlock\_fas\_t \*lock*);

*void*\

**ck\_spinlock\_fas\_lock**(*ck\_spinlock\_fas\_t \*lock*);

*void*\

**ck\_spinlock\_fas\_lock\_eb**(*ck\_spinlock\_fas\_t \*lock*);

*bool*\

**ck\_spinlock\_fas\_locked**(*ck\_spinlock\_fas\_t \*lock*);

*bool*\

**ck\_spinlock\_fas\_trylock**(*ck\_spinlock\_fas\_t \*lock*);

*void*\

**ck\_spinlock\_fas\_unlock**(*ck\_spinlock\_fas\_t \*lock*);

*void*\

**ck\_spinlock\_hclh\_init**(*ck\_spinlock\_hclh\_t \*\*lock*, *ck\_spinlock\_hclh\_t \*unowned*);

*bool*\

**ck\_spinlock\_hclh\_locked**(*ck\_spinlock\_hclh\_t \*\*lock*);

*void*\

**ck\_spinlock\_hclh\_lock**(*ck\_spinlock\_hclh\_t \*\*lock*, *ck\_spinlock\_hclh\_t \*node*);

*void*\

**ck\_spinlock\_hclh\_unlock**(*ck\_spinlock\_hclh\_t \*\*node*);

ck\_spinlock\_mcs\_t spinlock = CK\_SPINLOCK\_MCS\_INITIALIZER;

*void*\

**ck\_spinlock\_mcs\_init**(*ck\_spinlock\_mcs\_t \*\*lock*);

*bool*\

**ck\_spinlock\_mcs\_locked**(*ck\_spinlock\_mcs\_t \*\*lock*);

*void*\

**ck\_spinlock\_mcs\_lock**(*ck\_spinlock\_mcs\_t \*\*lock*, *ck\_spinlock\_mcs\_t \*node*);

*bool*\

**ck\_spinlock\_mcs\_trylock**(*ck\_spinlock\_mcs\_t \*\*lock*, *ck\_spinlock\_mcs\_t \*node*);

*void*\

**ck\_spinlock\_mcs\_unlock**(*ck\_spinlock\_mcs\_t \*\*lock*, *ck\_spinlock\_mcs\_t \*node*);

ck\_spinlock\_ticket\_t spinlock = CK\_SPINLOCK\_TICKET\_INITIALIZER;

*void*\

**ck\_spinlock\_ticket\_init**(*ck\_spinlock\_ticket\_t \*lock*);

*bool*\

**ck\_spinlock\_ticket\_locked**(*ck\_spinlock\_ticket\_t \*lock*);

*void*\

**ck\_spinlock\_ticket\_lock**(*ck\_spinlock\_ticket\_t \*lock*);

*void*\

**ck\_spinlock\_ticket\_lock\_pb**(*ck\_spinlock\_ticket\_t \*lock*, *unsigned int period*);

*bool*\

**ck\_spinlock\_ticket\_trylock**(*ck\_spinlock\_ticket\_t \*lock*);

*void*\

**ck\_spinlock\_ticket\_unlock**(*ck\_spinlock\_ticket\_t \*lock*);

## DESCRIPTION

A family of busy-wait spinlock implementations. The ck\_spinlock\_t implementation is simply a wrapper around the fetch-and-swap (ck\_spinlock\_fas\_t) implementation. The table below provides a summary of the current implementations.

```
|            Namespace | Algorithm                   | Type          | Restrictions            | Fair   |
´----------------------|-----------------------------|---------------|-------------------------|--------'
  ck_spinlock_anderson   Anderson                      Array           Fixed number of threads   Yes
       ck_spinlock_cas   Compare-and-Swap              Centralized     None                      No
       ck_spinlock_clh   Craig, Landin and Hagersten   Queue           Lifetime requirements     Yes
       ck_spinlock_dec   Decrement (Linux kernel)      Centralized     UINT_MAX concurrency      No
       ck_spinlock_fas   Fetch-and-store               Centralized     None                      No
       ck_spinlock_hclh  Hierarchical CLH              Queue           Lifetime requirements     Yes *
       ck_spinlock_mcs   Mellor-Crummey and Scott      Queue           None                      Yes
    ck_spinlock_ticket   Ticket                        Centralized     None                      Yes
```

\* Hierarchical CLH only offers weak fairness for threads accross cluster nodes.

If contention is low and there is no hard requirement for starvation-freedom then a centralized greedy (unfair) spinlock is recommended. If contention is high and there is no requirement for starvation-freedom then a centralized greedy spinlock is recommended to be used with an exponential backoff mechanism. If contention is generally low and there is a hard requirement for starvation-freedom then the ticket lock is recommended. If contention is high and there is a hard requirement for starvation-freedom then the Craig and Landin and Hagersten queue spinlock is recommended unless stack allocation is necessary or NUMA factor is high, in which case the Mellor-Crummey and Scott spinlock is recommended. If you cannot afford O(n) space-usage from array or queue spinlocks but still require fairness under high contention then the ticket lock with proportional back-off is recommended. If NUMA factor is high but prefer a greedy lock, then please see [ck\_cohort(3)](/ck_cohort/3.md).

## EXAMPLE

```
#include <ck_spinlock.h>
#include <stdbool.h>
/*
 * Alternatively, the mutex may be initialized at run-time with
 * ck_spinlock_init(&mutex).
 */
ck_spinlock_t mutex = CK_SPINLOCK_INITIALIZER;
void
example(void)
{
        ck_spinlock_lock(&mutex);
        /*
         * Critical section.
         */
        ck_spinlock_unlock(&mutex);
        ck_spinlock_lock_eb(&mutex);
        /*
         * Critical section.
         */
        ck_spinlock_unlock(&mutex);
        if (ck_spinlock_trylock(&mutex) == true) {
                /*
                 * Critical section.
                 */
                ck_spinlock_unlock(&mutex);
        }
}
```

## SEE ALSO

[ck\_cohort(3)](/ck_cohort/3.md), [ck\_elide(3)](/ck_elide/3.md)

Additional information available at http://concurrencykit.org/