Coordinate Counter Updates Across Threads

Question

This question asks the candidate to design a solution for coordinating updates to a shared counter across multiple threads, ensuring that each thread can operate independently while still providing a consistent snapshot of the counter's state.

Codemia · Accepted Answer

The problem requires us to implement two threads that modify a shared counter. One thread should terminate when the counter reaches 10, while the other should terminate after 1 second. Both threads must return a snapshot of the counter's value at the time of termination, and we need to print the sum of these snapshots.

To achieve this, we will use a shared counter variable protected by a mutex lock to ensure that updates are thread-safe. Each thread will have its own logic for updating the counter and checking for termination conditions. We will also use a condition variable to notify the threads when to stop waiting.

Here is a simple implementation in Python:

```python
import threading
import time

class Counter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()

def increment(self):
        with self.lock:
            self.value += 1
            return self.value

def get_value(self):
        with self.lock:
            return self.value

counter = Counter()

def thread_one(counter):
    while True:
        if counter.increment() >= 10:
            return counter.get_value()

def thread_two(counter):
    time.sleep(1)
    return counter.get_value()

thread1 = threading.Thread(target=thread_one, args=(counter,))
thread2 = threading.Thread(target=thread_two, args=(counter,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

snapshot_sum = thread1.result + thread2.result
print(f'Snapshot sum: {snapshot_sum}')
```

Using locks can introduce overhead and may lead to contention if many threads are trying to access the counter simultaneously. To improve scalability, we could explore using atomic operations or lock-free data structures. Additionally, we should consider the impact of context switching on performance, especially if the threads are frequently yielding control.

Coordinate Counter Updates Across Threads

Tesla

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Requirements

High-Level Design

Submit Your Answer

Tesla Software Engineer Interview Guide

Related Questions

Design a scalable Search System

Design a Video Streaming for Rippling

Design a Load Balancing Service

Design a Image Processing Service

Build a high-throughput Image Processing Pipeline