Print in Order - Practice Coding Problems

Print in Order - Problem

Concurrency Easy

Thread Synchronization Challenge: Print in Order

Imagine you're conducting an orchestra where three musicians need to play their parts in perfect sequence, but they can't see or hear each other! This classic concurrency problem asks you to coordinate multiple threads to execute methods in a specific order.

You're given a class Foo with three methods:

first() - prints "first"
second() - prints "second"
third() - prints "third"

The challenge: Three different threads will call these methods simultaneously, but you must ensure they execute in the correct order: first → second → third. The operating system scheduler is unpredictable, so without proper synchronization, the output could be jumbled!

Goal: Design a thread-safe mechanism to guarantee sequential execution regardless of thread scheduling.

Input & Output

example_1.py — Basic Execution Order

$ Input: Thread execution order: [1,2,3]

› Output: "firstsecondthird"

💡 Note: Even though threads start in order 1→2→3, the synchronization mechanism ensures they execute their methods in the correct sequence regardless of timing.

example_2.py — Reverse Thread Start

$ Input: Thread execution order: [3,1,2]

› Output: "firstsecondthird"

💡 Note: Despite thread 3 starting first, it must wait for threads 1 and 2 to complete their work. The synchronization ensures proper ordering.

example_3.py — Random Thread Timing

$ Input: Thread execution order: [2,3,1]

› Output: "firstsecondthird"

💡 Note: No matter how the OS schedules these threads, the output is always consistent thanks to our synchronization mechanism.

Visualization

Tap to expand

Understanding the Visualization

All chefs start cooking

Three chefs begin preparation simultaneously, but main course and dessert chefs wait for signals

Appetizer ready!

Appetizer chef finishes and rings the bell, signaling the main course chef to serve

Main course served

Main course chef serves their dish and signals the dessert chef

Perfect sequence complete

Dessert chef receives the signal and serves the final course - meal served in perfect order!

Key Takeaway

🎯 Key Insight: Use synchronization primitives like semaphores to coordinate threads efficiently - no busy waiting, just clean signals when each step is complete!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each method executes exactly once with minimal blocking overhead

✓ Linear Growth

Space Complexity

O(1)

Only requires a few semaphore objects for coordination

✓ Linear Space

Constraints

Exactly three threads will be created
Each thread calls exactly one method on the same Foo instance
Thread scheduling order is unpredictable and not guaranteed
Methods must execute in exact order: first() → second() → third()
Solution must work regardless of OS thread scheduling

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 28

The optimal solution uses semaphores (or equivalent synchronization primitives) to coordinate thread execution. Instead of wasteful busy-waiting, threads block efficiently until signaled by their predecessor, ensuring perfect sequencing with minimal CPU overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Semaphore Synchronization	O(1)	O(1)	Use semaphores to block threads until their turn arrives
Busy Waiting with Flags	O(1)	O(1)	Use volatile flags and continuously check conditions in loops

Semaphore Synchronization — Algorithm Steps

Initialize semaphores with appropriate permits (0 for blocking)
First thread executes immediately and releases next semaphore
Second thread waits on first semaphore, then releases third
Third thread waits on second semaphore before executing
Each thread blocks efficiently until signaled

Visualization

Tap to expand

Step-by-Step Walkthrough

Threads start

All threads begin, but second/third block on semaphores

First executes

First thread runs immediately and signals completion

Second unblocks

Second thread receives signal and proceeds

Third unblocks

Third thread receives signal and completes

Code -

solution.c — C

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

typedef struct {
    sem_t firstDone;
    sem_t secondDone;
} Foo;

void printFirst() { printf("first"); }
void printSecond() { printf("second"); }
void printThird() { printf("third"); }

void* first(void* arg) {
    Foo* foo = (Foo*)arg;
    printFirst();
    sem_post(&foo->firstDone);
    return NULL;
}

void* second(void* arg) {
    Foo* foo = (Foo*)arg;
    sem_wait(&foo->firstDone);
    printSecond();
    sem_post(&foo->secondDone);
    return NULL;
}

void* third(void* arg) {
    Foo* foo = (Foo*)arg;
    sem_wait(&foo->secondDone);
    printThird();
    return NULL;
}

int main() {
    Foo foo;
    sem_init(&foo.firstDone, 0, 0);
    sem_init(&foo.secondDone, 0, 0);
    
    pthread_t t1, t2, t3;
    pthread_create(&t1, NULL, third, &foo);
    pthread_create(&t2, NULL, first, &foo);
    pthread_create(&t3, NULL, second, &foo);
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    
    sem_destroy(&foo.firstDone);
    sem_destroy(&foo.secondDone);
    printf("\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each method executes exactly once with minimal blocking overhead

✓ Linear Growth

Space Complexity

O(1)

Only requires a few semaphore objects for coordination

✓ Linear Space

Constraints

Exactly three threads will be created
Each thread calls exactly one method on the same Foo instance
Thread scheduling order is unpredictable and not guaranteed
Methods must execute in exact order: first() → second() → third()
Solution must work regardless of OS thread scheduling

89.2K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Semaphore Synchronization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler