Lecture 15: Thread Local Objects


  1. Queue Locking Strategy
  2. Thread Objects
  3. Implementing CLH Lock

Last Time


  • TAS lock
  • TTAS lock
  • Backoff lock


  • Not starvation-free
  • All threads access same variable concurrently


Implementing a queue-based lock

  • Idea:
    • use linked list representation of a queue
    • each thread controls a node, sees predecessor node
    • use node to signal status to successor
  • New construction:
    • thread local objects

CLH Lock

Each thread has:

  • Node myNode node “owned” by thread
  • Node myPred node owned by predecessor thread

Each Node has:

  • boolean locked:
    • myNode.locked = true signals I want/have lock
    • myNode.locked = false signals I have released lock

Thread acquires lock when myPred.locked is false

CLH Lock Initial State

Thread 1 Arrives

Thread 1 Acquires Lock

Thread 2 Arrives

Thread 2 Locks

Thread 3 Arrives

Thread 3 Locks

Thread 1 Unlocks (1)

Thread 1 Unlocks (2)

Thread 2 Unlocks

Thread 3 Unlocks

A Subtlety

When a node locks, 2 things happen:

  • updates (shared) tail
  • updates (own) myPred

In what order should these updates occur?

Swapping Atomically

Use AtomicReference<...> class

  • has getAndSet method
    • returns previous value
    • sets new value
    • atomic
  • use myPred = tail.getAndSet(myNode)

Another Subtlety

Each thread has own variables

  • myNode
  • myPred

How do we get different variables for each thread???

Interlude: Thread-local Objects

Java (generic) class: ThreadLocal<T>

  • Make a T for each thread
  • Some ThreadLocal methods:
    • T get() returns current thread’s copy of variable
    • protected T initialValue() returns current thread’s initial value
      • you’ll want to @Override this to initialize
    • void set(T value) set value of current thread’s copy

Ugly Syntax

Make a MyClass instance for each thread:

public class TLObjects {
    private ThreadLocal<MyClass> myInstance =
        new ThreadLocal<MyClass>() {
            protected MyClass initialValue() {
                return new MyClass(...args...);

Uses anonymous inner class construction

  • syntax of constructor call, followed by {...}
  • ...” implements/overrides methods

An Example: ThreadId

Make a class that assigns IDs to threads sequentially


  • static AtomicInteger that stores next ID to be assigned
  • static ThreadLocal<Integer> that stores thread’s ID


  • static int get() returns value of thread’s ID

Why is everything static?

ThreadID in Code

Using ThreadLocal for CLHLock


  • Shared reference to tail node
    • must be AtomicReference to getAndSet atomically
  • Thread local (references to) nodes
    • myNode, the Node I initially own
    • predNode, initially null


  • lock()
    • set myNode.locked = ture
    • atomically:
      • get shared tail node
      • set tail to myNode
    • wait until myPred.locked == false
  • unlock()
    • set myNode.locked = false (releases lock)
    • update myNode to myPred

Testing CLHLock

Next Time

  • Linked Lists