Overview

The sleep() and yield() methods are used for thread management in Java. They help in controlling thread execution and resource sharing.

1. Thread.sleep() Method

Basic sleep() Usage

public class SleepBasic {
public static void main(String[] args) {
System.out.println("Program started at: " + java.time.LocalTime.now());
try {
// Sleep for 2 seconds
System.out.println("Going to sleep for 2 seconds...");
Thread.sleep(2000); // 2000 milliseconds = 2 seconds
System.out.println("Woke up at: " + java.time.LocalTime.now());
// Sleep for 500 milliseconds
System.out.println("Sleeping for 500 ms...");
Thread.sleep(500);
System.out.println("Woke up again at: " + java.time.LocalTime.now());
} catch (InterruptedException e) {
System.out.println("Sleep was interrupted: " + e.getMessage());
}
}
}

sleep() with Different Time Units

public class SleepTimeUnits {
public static void main(String[] args) {
System.out.println("=== Different Sleep Durations ===");
try {
// Sleep for seconds
System.out.println("Sleeping for 3 seconds...");
Thread.sleep(3000);
System.out.println("Awake!");
// Sleep for milliseconds
System.out.println("Sleeping for 1500 milliseconds...");
Thread.sleep(1500);
System.out.println("Awake!");
// Sleep for minutes (converted to milliseconds)
System.out.println("Sleeping for 10 seconds (simulating minutes)...");
Thread.sleep(10 * 1000); // 10 seconds instead of 10 minutes for demo
System.out.println("Awake after '10 minutes'!");
} catch (InterruptedException e) {
System.out.println("Sleep interrupted: " + e.getMessage());
}
}
// Utility method for readable sleep calls
public static void sleepSeconds(int seconds) {
try {
Thread.sleep(seconds * 1000L);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Sleep was interrupted", e);
}
}
public static void sleepMillis(long milliseconds) {
try {
Thread.sleep(milliseconds);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Sleep was interrupted", e);
}
}
}

sleep() in Multiple Threads

public class SleepMultipleThreads {
static class SleepingThread extends Thread {
private String name;
private int sleepTime;
public SleepingThread(String name, int sleepTime) {
this.name = name;
this.sleepTime = sleepTime;
}
@Override
public void run() {
System.out.println(name + " started at: " + java.time.LocalTime.now());
try {
// Each thread sleeps for different durations
System.out.println(name + " is sleeping for " + sleepTime + "ms");
Thread.sleep(sleepTime);
System.out.println(name + " woke up at: " + java.time.LocalTime.now());
} catch (InterruptedException e) {
System.out.println(name + " was interrupted: " + e.getMessage());
}
}
}
public static void main(String[] args) {
System.out.println("Main thread started at: " + java.time.LocalTime.now());
// Create multiple threads with different sleep times
Thread t1 = new SleepingThread("Thread-1", 2000);
Thread t2 = new SleepingThread("Thread-2", 3000);
Thread t3 = new SleepingThread("Thread-3", 1000);
// Start all threads
t1.start();
t2.start();
t3.start();
// Wait for all threads to complete
try {
t1.join();
t2.join();
t3.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("All threads completed at: " + java.time.LocalTime.now());
}
}

sleep() with Interruption Handling

public class SleepInterruption {
static class InterruptibleTask extends Thread {
private String taskName;
public InterruptibleTask(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
System.out.println(taskName + " started");
try {
// Simulate long-running task with sleep
for (int i = 1; i <= 5; i++) {
System.out.println(taskName + " - Step " + i);
Thread.sleep(1000); // Sleep for 1 second between steps
// Check if thread was interrupted during sleep
if (Thread.currentThread().isInterrupted()) {
System.out.println(taskName + " was interrupted during step " + i);
return;
}
}
System.out.println(taskName + " completed successfully");
} catch (InterruptedException e) {
System.out.println(taskName + " was interrupted with exception: " + e.getMessage());
// Restore interrupt status
Thread.currentThread().interrupt();
}
}
}
public static void main(String[] args) {
InterruptibleTask task = new InterruptibleTask("LongRunningTask");
System.out.println("Starting task...");
task.start();
// Let the task run for 2.5 seconds then interrupt it
try {
Thread.sleep(2500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Interrupting task...");
task.interrupt();
// Wait for task to finish
try {
task.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main thread completed");
}
}

2. Thread.yield() Method

Basic yield() Usage

public class YieldBasic {
static class YieldingThread extends Thread {
private String name;
private int iterations;
public YieldingThread(String name, int iterations) {
this.name = name;
this.iterations = iterations;
}
@Override
public void run() {
for (int i = 1; i <= iterations; i++) {
System.out.println(name + " - Iteration " + i);
// Yield control to other threads
Thread.yield();
}
System.out.println(name + " completed");
}
}
public static void main(String[] args) {
System.out.println("=== Yield Demonstration ===");
// Create threads with different priorities
YieldingThread t1 = new YieldingThread("Low-Priority-Thread", 5);
YieldingThread t2 = new YieldingThread("High-Priority-Thread", 5);
// Set thread priorities
t1.setPriority(Thread.MIN_PRIORITY);    // Priority 1
t2.setPriority(Thread.MAX_PRIORITY);    // Priority 10
System.out.println("Starting threads...");
t1.start();
t2.start();
// Wait for threads to complete
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main thread completed");
}
}

yield() vs sleep() Comparison

public class YieldVsSleep {
static class YieldTask extends Thread {
private String name;
public YieldTask(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println(name + " - Before yield - Iteration " + i);
Thread.yield(); // Hint to scheduler
System.out.println(name + " - After yield - Iteration " + i);
}
}
}
static class SleepTask extends Thread {
private String name;
public SleepTask(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println(name + " - Before sleep - Iteration " + i);
try {
Thread.sleep(10); // Guaranteed to sleep
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " - After sleep - Iteration " + i);
}
}
}
public static void main(String[] args) {
System.out.println("=== Yield vs Sleep Comparison ===");
System.out.println("\n--- Using Yield ---");
Thread y1 = new YieldTask("Yield-Thread-1");
Thread y2 = new YieldTask("Yield-Thread-2");
y1.start();
y2.start();
try {
y1.join();
y2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\n--- Using Sleep ---");
Thread s1 = new SleepTask("Sleep-Thread-1");
Thread s2 = new SleepTask("Sleep-Thread-2");
s1.start();
s2.start();
try {
s1.join();
s2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("\nComparison completed");
}
}

3. Practical Examples

Rate Limiting with sleep()

public class RateLimiting {
static class RateLimitedService {
private final long minIntervalMs;
private long lastCallTime;
public RateLimitedService(long minIntervalMs) {
this.minIntervalMs = minIntervalMs;
this.lastCallTime = 0;
}
public void callService(String request) {
long currentTime = System.currentTimeMillis();
long timeSinceLastCall = currentTime - lastCallTime;
// If called too soon, sleep for remaining time
if (timeSinceLastCall < minIntervalMs) {
long sleepTime = minIntervalMs - timeSinceLastCall;
System.out.println("Rate limit exceeded. Sleeping for " + sleepTime + "ms");
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
// Execute the service call
System.out.println("Processing: " + request + " at " + 
java.time.LocalTime.now());
lastCallTime = System.currentTimeMillis();
}
}
public static void main(String[] args) {
// Create service that can only be called once per second
RateLimitedService service = new RateLimitedService(1000);
System.out.println("=== Rate Limiting Demo ===");
// Simulate rapid calls
for (int i = 1; i <= 5; i++) {
service.callService("Request-" + i);
}
System.out.println("All requests processed");
}
}

Producer-Consumer with sleep() for Timing

import java.util.*;
import java.util.concurrent.*;
public class ProducerConsumerWithSleep {
static class SharedBuffer {
private Queue<Integer> buffer = new LinkedList<>();
private final int capacity;
public SharedBuffer(int capacity) {
this.capacity = capacity;
}
public synchronized void produce(int value) throws InterruptedException {
while (buffer.size() == capacity) {
System.out.println("Buffer full, producer waiting...");
wait();
}
buffer.add(value);
System.out.println("Produced: " + value + " | Buffer size: " + buffer.size());
notifyAll();
}
public synchronized int consume() throws InterruptedException {
while (buffer.isEmpty()) {
System.out.println("Buffer empty, consumer waiting...");
wait();
}
int value = buffer.remove();
System.out.println("Consumed: " + value + " | Buffer size: " + buffer.size());
notifyAll();
return value;
}
}
static class Producer extends Thread {
private SharedBuffer buffer;
private int itemsToProduce;
public Producer(SharedBuffer buffer, int itemsToProduce) {
this.buffer = buffer;
this.itemsToProduce = itemsToProduce;
}
@Override
public void run() {
try {
for (int i = 1; i <= itemsToProduce; i++) {
buffer.produce(i);
// Simulate production time with sleep
Thread.sleep(new Random().nextInt(500) + 100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
static class Consumer extends Thread {
private SharedBuffer buffer;
private int itemsToConsume;
public Consumer(SharedBuffer buffer, int itemsToConsume) {
this.buffer = buffer;
this.itemsToConsume = itemsToConsume;
}
@Override
public void run() {
try {
for (int i = 1; i <= itemsToConsume; i++) {
buffer.consume();
// Simulate consumption time with sleep
Thread.sleep(new Random().nextInt(800) + 200);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Producer-Consumer with Sleep ===");
SharedBuffer buffer = new SharedBuffer(3);
Producer producer = new Producer(buffer, 10);
Consumer consumer = new Consumer(buffer, 10);
producer.start();
consumer.start();
producer.join();
consumer.join();
System.out.println("Producer-Consumer completed");
}
}

CPU Intensive Task with yield()

public class CPUIntensiveWithYield {
static class CPUIntensiveTask extends Thread {
private String name;
private int computations;
private boolean useYield;
public CPUIntensiveTask(String name, int computations, boolean useYield) {
this.name = name;
this.computations = computations;
this.useYield = useYield;
}
@Override
public void run() {
long startTime = System.currentTimeMillis();
for (int i = 0; i < computations; i++) {
// Simulate CPU-intensive computation
double result = Math.sqrt(Math.pow(i, 3) + Math.pow(i, 2) + i);
if (useYield && i % 1000 == 0) {
// Yield every 1000 computations to be polite
Thread.yield();
}
}
long endTime = System.currentTimeMillis();
System.out.println(name + " completed in " + (endTime - startTime) + "ms");
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== CPU Intensive Tasks with Yield ===");
// Without yield
System.out.println("\n--- Without Yield ---");
CPUIntensiveTask task1 = new CPUIntensiveTask("Task-No-Yield", 1000000, false);
CPUIntensiveTask task2 = new CPUIntensiveTask("Task-No-Yield", 1000000, false);
task1.start();
task2.start();
task1.join();
task2.join();
// With yield
System.out.println("\n--- With Yield ---");
CPUIntensiveTask task3 = new CPUIntensiveTask("Task-With-Yield", 1000000, true);
CPUIntensiveTask task4 = new CPUIntensiveTask("Task-With-Yield", 1000000, true);
task3.start();
task4.start();
task3.join();
task4.join();
System.out.println("\nComparison completed");
}
}

4. Advanced Examples

Scheduled Task Execution

public class ScheduledTasks {
static class ScheduledTask extends Thread {
private String taskName;
private long intervalMs;
private int executions;
private volatile boolean running = true;
public ScheduledTask(String taskName, long intervalMs, int executions) {
this.taskName = taskName;
this.intervalMs = intervalMs;
this.executions = executions;
}
public void stopTask() {
running = false;
interrupt(); // Interrupt if sleeping
}
@Override
public void run() {
int count = 0;
while (running && count < executions) {
count++;
// Execute task
System.out.println(taskName + " executed #" + count + " at " + 
java.time.LocalTime.now());
// Sleep until next execution
if (running && count < executions) {
try {
Thread.sleep(intervalMs);
} catch (InterruptedException e) {
System.out.println(taskName + " was interrupted");
break;
}
}
}
System.out.println(taskName + " completed after " + count + " executions");
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Scheduled Tasks Demo ===");
// Create tasks with different intervals
ScheduledTask task1 = new ScheduledTask("Fast-Task", 1000, 5);    // 1 second interval
ScheduledTask task2 = new ScheduledTask("Slow-Task", 3000, 3);    // 3 second interval
task1.start();
task2.start();
// Let tasks run for a while
Thread.sleep(10000);
// Stop tasks
System.out.println("Stopping tasks...");
task1.stopTask();
task2.stopTask();
task1.join();
task2.join();
System.out.println("All tasks stopped");
}
}

Animation Loop with sleep()

public class AnimationLoop {
static class Animation extends Thread {
private volatile boolean running = true;
private int frameRate; // Frames per second
private String[] frames;
private int currentFrame = 0;
public Animation(int frameRate, String[] frames) {
this.frameRate = frameRate;
this.frames = frames;
}
public void stopAnimation() {
running = false;
interrupt();
}
@Override
public void run() {
long frameInterval = 1000 / frameRate; // ms per frame
long nextFrameTime = System.currentTimeMillis();
while (running) {
// Display current frame
System.out.print("\r" + frames[currentFrame]);
currentFrame = (currentFrame + 1) % frames.length;
// Calculate next frame time
nextFrameTime += frameInterval;
long sleepTime = nextFrameTime - System.currentTimeMillis();
if (sleepTime > 0) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
System.out.println("\nAnimation interrupted");
break;
}
}
}
System.out.println("\nAnimation stopped");
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Animation Loop Demo ===");
String[] spinnerFrames = {"|", "/", "-", "\\"};
Animation spinner = new Animation(10, spinnerFrames);
System.out.print("Loading: ");
spinner.start();
// Let animation run for 5 seconds
Thread.sleep(5000);
spinner.stopAnimation();
spinner.join();
System.out.println("Demo completed");
}
}

5. Best Practices and Common Pitfalls

Best Practices Examples

public class SleepYieldBestPractices {
// 1. Always handle InterruptedException properly
static class ProperInterruptionHandling extends Thread {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
try {
// Do some work
System.out.println("Working...");
Thread.sleep(1000);
} catch (InterruptedException e) {
// Restore interrupt status and exit
System.out.println("Thread interrupted, cleaning up...");
Thread.currentThread().interrupt();
break;
}
}
System.out.println("Thread exiting gracefully");
}
}
// 2. Use sleep for timing, not for synchronization
static class ProperSynchronization {
private final Object lock = new Object();
private boolean dataReady = false;
public void waitForData() throws InterruptedException {
synchronized (lock) {
while (!dataReady) {
lock.wait(); // Use wait() instead of sleep() for coordination
}
// Process data
}
}
public void setDataReady() {
synchronized (lock) {
dataReady = true;
lock.notifyAll();
}
}
}
// 3. Avoid busy waiting - use sleep instead
static class AvoidBusyWaiting {
private volatile boolean condition = false;
// BAD: Busy waiting
public void badWaitForCondition() {
while (!condition) {
// Empty loop - wastes CPU cycles
}
}
// GOOD: Using sleep
public void goodWaitForCondition() throws InterruptedException {
while (!condition) {
Thread.sleep(100); // Check condition periodically
}
}
}
// 4. Use yield() for cooperative multitasking in CPU-intensive tasks
static class CooperativeTask extends Thread {
private String name;
private int workUnits;
public CooperativeTask(String name, int workUnits) {
this.name = name;
this.workUnits = workUnits;
}
@Override
public void run() {
for (int i = 0; i < workUnits; i++) {
// Simulate CPU work
performComputation(i);
// Yield periodically to be polite to other threads
if (i % 100 == 0) {
Thread.yield();
}
}
System.out.println(name + " completed");
}
private void performComputation(int i) {
// Simulate some computation
Math.sqrt(i * i + i);
}
}
// 5. Use TimeUnit for readable sleep calls
static class ReadableSleep {
public void demonstrateTimeUnit() throws InterruptedException {
// More readable than Thread.sleep(5000)
java.util.concurrent.TimeUnit.SECONDS.sleep(5);
java.util.concurrent.TimeUnit.MILLISECONDS.sleep(500);
java.util.concurrent.TimeUnit.MINUTES.sleep(1); // In real code, not demo
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Best Practices Demo ===");
// Demonstrate proper interruption handling
System.out.println("\n1. Proper Interruption Handling:");
ProperInterruptionHandling thread = new ProperInterruptionHandling();
thread.start();
Thread.sleep(2500);
thread.interrupt();
thread.join();
// Demonstrate cooperative tasks
System.out.println("\n2. Cooperative Multitasking:");
CooperativeTask task1 = new CooperativeTask("Coop-Task-1", 1000);
CooperativeTask task2 = new CooperativeTask("Coop-Task-2", 1000);
task1.start();
task2.start();
task1.join();
task2.join();
System.out.println("\nAll best practices demonstrated");
}
}

Common Pitfalls to Avoid

public class SleepYieldPitfalls {
// 1. Pitfall: Assuming sleep() is precise
static class PreciseTiming {
public void inaccurateTimer() throws InterruptedException {
long start = System.currentTimeMillis();
// Sleep for exactly 1 second? Not guaranteed!
Thread.sleep(1000);
long end = System.currentTimeMillis();
long actualSleep = end - start;
System.out.println("Requested sleep: 1000ms, Actual sleep: " + actualSleep + "ms");
}
public void betterTimer() throws InterruptedException {
long desiredEnd = System.currentTimeMillis() + 1000;
while (System.currentTimeMillis() < desiredEnd) {
long remaining = desiredEnd - System.currentTimeMillis();
if (remaining > 0) {
Thread.sleep(remaining);
}
}
}
}
// 2. Pitfall: Not handling spurious wakeups
static class SpuriousWakeup {
private final Object lock = new Object();
private boolean condition = false;
public void badWait() throws InterruptedException {
synchronized (lock) {
if (!condition) {
lock.wait(); // Might wake up without notify!
}
}
}
public void goodWait() throws InterruptedException {
synchronized (lock) {
while (!condition) { // Always use while loop
lock.wait();
}
}
}
}
// 3. Pitfall: Using yield() for synchronization
static class YieldSynchronization {
private volatile int counter = 0;
// BAD: Using yield for synchronization
public void badIncrement() {
// This doesn't guarantee proper synchronization
counter++;
Thread.yield();
}
// GOOD: Proper synchronization
public synchronized void goodIncrement() {
counter++;
}
}
// 4. Pitfall: Ignoring interrupt status
static class IgnoreInterrupt {
public void badSleepMethod() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// BAD: Just ignoring the exception
System.out.println("Interrupted, but continuing...");
}
}
public void goodSleepMethod() throws InterruptedException {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// GOOD: Restore interrupt status and handle appropriately
Thread.currentThread().interrupt();
throw e; // Or return, depending on context
}
}
}
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Common Pitfalls ===");
PreciseTiming timer = new PreciseTiming();
timer.inaccurateTimer();
System.out.println("\nPitfalls demonstrated");
}
}

Key Differences Summary

Best Practices Summary

1. Always handle InterruptedException - restore interrupt status
2. Use sleep() for timing, not for thread coordination
3. Use yield() sparingly - mostly for CPU-intensive cooperative tasks
4. Prefer TimeUnit for more readable sleep calls
5. Never rely on sleep() precision for critical timing
6. Avoid busy waiting - use sleep with periodic checks
7. Don't use yield() for synchronization - use proper synchronization primitives

Understanding when and how to use sleep() and yield() is crucial for writing efficient and responsive multi-threaded Java applications.