Introduction

The direct Objective-C equivalent of Java's Thread.sleep(...) is [NSThread sleepForTimeInterval:] or [NSThread sleepUntilDate:]. But in Cocoa applications, the bigger question is usually whether you should sleep the current thread at all. On the main thread, sleeping blocks the run loop and freezes the UI, so scheduled or asynchronous alternatives are often the better design.

The direct equivalent is NSThread

If you truly want to pause the current thread, use NSThread:

[NSThread sleepForTimeInterval:2.0];

That pauses the current thread for two seconds, similar to Java:

Thread.sleep(2000);

Objective-C also has a date-based variant:

NSDate *wakeTime = [NSDate dateWithTimeIntervalSinceNow:3.0];
[NSThread sleepUntilDate:wakeTime];

Functionally, these are the closest equivalents.

C-level sleep functions also exist

Because Objective-C sits on top of C, you can also use the POSIX sleep functions:

1#include <unistd.h>
2
3sleep(2);       // seconds
4usleep(500000); // microseconds

These are valid, but in Cocoa code NSThread usually communicates intent more clearly.

Do not sleep the main thread in a Cocoa app

This is the most important practical point. If you sleep the main thread, the app stops processing events, drawing updates, and user interaction while it waits.

1- (void)buttonTapped {
2    [NSThread sleepForTimeInterval:3.0];
3    self.statusLabel.text = @"Done";
4}

That code "works," but the interface freezes for three seconds. In a desktop or iOS UI, that is usually the wrong behavior.

Use delayed execution instead of blocking

If the goal is "do something later" rather than "block this thread," schedule the work instead of sleeping.

With Grand Central Dispatch:

1dispatch_after(
2    dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
3    dispatch_get_main_queue(),
4    ^{
5        self.statusLabel.text = @"Done";
6    }
7);

This keeps the run loop responsive. The UI remains usable while the delay is pending.

For repeating or run-loop-based delayed work, NSTimer is also appropriate:

1[NSTimer scheduledTimerWithTimeInterval:2.0
2                                 target:self
3                               selector:@selector(timerFired:)
4                               userInfo:nil
5                                repeats:NO];
6
7- (void)timerFired:(NSTimer *)timer {
8    NSLog(@"Timer fired");
9}

Sleep is acceptable on a background thread

If you are doing background work and a deliberate pause is part of the logic, sleeping there is less problematic. The important thing is to keep UI updates on the main queue.

1dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
2    [NSThread sleepForTimeInterval:2.0];
3
4    dispatch_async(dispatch_get_main_queue(), ^{
5        self.statusLabel.text = @"Background work done";
6    });
7});

That pattern is far better than blocking the main thread while waiting.

Think about intent before choosing the API

A good rule is:

• use NSThread sleepForTimeInterval: only when you truly want to pause the current thread
• use dispatch_after when you want to run code later
• use NSTimer when you want timer-style behavior tied to a run loop
• use background queues when waiting should not block the UI

Many uses of Thread.sleep() in Java translate more naturally to scheduled execution in Cocoa than to literal sleeping.

Common Pitfalls

The most common mistake is using sleepForTimeInterval: on the main thread and then wondering why the app freezes.

Another common issue is using sleep as a synchronization mechanism. That usually creates brittle timing-dependent code rather than real coordination.

People also forget that delayed UI work and blocked threads are different requirements. dispatch_after is often the right answer when the goal is simply "run this a bit later."

Finally, if you sleep on a background queue, remember that UI updates still must return to the main queue.

Summary

• The direct Objective-C equivalent of Thread.sleep is [NSThread sleepForTimeInterval:].
• C functions such as sleep and usleep also exist, but NSThread is clearer in Cocoa code.
• Never sleep the main thread in a UI app unless freezing the interface is truly acceptable.
• Use dispatch_after or NSTimer when the goal is delayed execution rather than blocking.
• Background sleeps are acceptable when the pause belongs to background work and UI updates return to the main queue.