How to tell Ruby program to wait for some amount of time?

In the fast-paced world of programming, there are times when you want your Ruby program to take a breather. This could involve waiting for user input, simulating delays for realistic interactions, or ensuring other processes finish before continuing. This article explores various techniques for introducing pauses into your Ruby code.

1. Using `sleep`:

The built-in `sleep` method is the simplest approach for halting execution for a specified duration. It takes a single argument, which is the number of seconds to wait. Here's how to use it:

Ruby

puts "Starting process..."
sleep 3  # Wait for 3 seconds
puts "Process completed!"

2. Granular Control with `sleep`:

For more fine-grained control, you can use fractions of seconds. `sleep` accepts floating-point numbers, allowing you to wait for milliseconds as well.

Ruby

puts "Simulating user interaction..."
sleep 0.5  # Wait for half a second

# Simulate typing time
10.times do |i|
  sleep 0.1  # Wait 0.1 seconds between each character
  print " *"
end

puts "\nUser has finished typing."

3. The `Time` Class for Time-Based Waits:

The `Time` class offers more advanced methods for controlling waits based on specific time intervals. Here are some commonly used methods:

`Time.now`: Returns the current time as a `Time` object.
`sleep` (within `Time` class): Similar to the built-in `sleep`, but can be used with `Time` objects for duration calculations.

Example:

Ruby

start_time = Time.now  # Record the starting time

# Some processing that takes time

end_time = Time.now  # Record the finishing time
total_time = end_time - start_time  # Calculate elapsed time

# Ensure a minimum execution time of 5 seconds
if total_time < 5
  sleep 5 - total_time  # Wait for the remaining time
end

puts "Minimum execution time of 5 seconds met."

4. Non-Blocking Waits with Threads:

If you need your program to remain responsive while waiting, consider using threads. Threads allow you to execute code concurrently. You can create a separate thread for the waiting task and continue with other operations in the main thread. Libraries like `Thread` and `Concurrent::TimerTask` (part of the `concurrent-ruby` gem) offer thread management functionalities.

Example (using `Thread` library):

Ruby

# Create a thread to wait for 2 seconds
wait_thread = Thread.new do
  sleep 2
  puts "Waiting task completed!"
end

# Continue with other program logic here

# Wait for the waiting thread to finish (optional)
wait_thread.join

Choosing the Right Approach:

The best method for introducing pauses in your Ruby program depends on your specific requirements:

`sleep` is straightforward for simple delays.
Use `sleep` with fractions for fine-grained control in milliseconds.
Utilize the `Time` class for time-based waits and minimum execution time guarantees.
Explore threads if you need non-blocking waits and concurrent execution.

By understanding these techniques, you can effectively control the flow of your Ruby programs, ensuring they wait when necessary and maintain responsiveness.

Article Tags :

Ruby