Role of Thread.sleep() in Selenium

When automating a web application, we occasionally run across the NoSuchElementException exception, which is thrown when the element being interacted with cannot be located.

The main reason for this error is that the element that has to be interacted with is present on the page but takes some time to load and show up for the user. You can see how this could become a significant problem during automation and cause our scripts to fail. Here is when Selenium Java’s Thread.sleep() function comes into action.

Let’s first learn the fundamentals of the Thread.sleep() Selenium sleep function before we look at how to use it effectively.

Overview of Thread.sleep()?

Thread.sleep is a wait command in Selenium  that instructs the program to suspend the execution for a certain condition or a specific amount of time.

Here are some reasons why wait commands are necessary in Selenium.

• Page loading: Web pages can take varying amounts of time to load depending on network speed, server response time, and other factors. If you try to interact with elements on the page before the page has fully loaded, your script may fail.


• Dynamic content: Many modern web pages use dynamic content that is loaded asynchronously, meaning that it can take time for certain elements to become available. If you try to interact with these elements before they are available, your script may fail.


• Latency: Network latency can cause delays in the time it takes for elements on a page to become available. If you don’t use wait commands, your script may fail if it attempts to interact with elements before they are fully loaded.


• Animations: Some web pages use animations or other visual effects that can cause delays in the loading of elements or the timing of events on the page. If you don’t use wait commands, your script may fail if it attempts to interact with elements during these animations.

Types of Wait Commands in Selenium Java.

There are three types of wait commands in Selenium Java:

• Implicit Wait: Implicit waits are used to set a default waiting time for the web driver to search for an element if it is not immediately available. It is applied to the driver instance globally and is set using the driver.manage().timeouts().implicitlyWait() method. Once set, the implicit wait will remain in effect for the entire lifetime of the WebDriver object, and it will wait for the specified time before throwing a NoSuchElementException. This is useful when you have to perform several operations on a web page that may load or change over time.


• Explicit Wait: Explicit waits are used to wait for a specific condition to occur before proceeding further in the script. You can define a custom wait condition using the ExpectedConditions class provided by Selenium. The explicit wait is triggered when you use the WebDriverWait class and specify a maximum wait time using the until method. It checks for the presence, visibility, or any other condition of a web element before proceeding. If the condition is not met within the specified time, it throws a TimeoutException.


• Fluent Wait: Fluent waits are used to define more complex waiting strategies that involve polling for an element repeatedly until a specific condition is met. It can be used to wait for an element to become clickable, and visible, or to wait for a certain amount of time. It is created using the Wait interface and is used to define the maximum wait time, the polling interval, and the condition to wait for. The fluent wait is more flexible than the implicit and explicit waits and allows you to define a custom condition and polling interval, making it useful for waiting for elements that may load or change over time.

Using these wait commands can help to ensure that your Selenium scripts are more stable and reliable by allowing the script to wait for the web page to load or for specific elements to become available before proceeding further.

How does Thread.sleep() work?

Thread.sleep() is a method in Java that pauses the current thread for a specified amount of time, allowing other threads to execute. When you call Thread.sleep(), the current thread enters a blocked state for the duration of the sleep period. During this time, the thread doesn’t execute any code and doesn’t consume any CPU resources.

Here’s how Thread.sleep() works:

1. When you call Thread.sleep(), the current thread enters a blocked state, which means it’s waiting for a certain amount of time to elapse.


2. The thread scheduler removes the blocked thread from the list of threads that are ready to execute and puts it in a waiting state.


3. While the thread is in a waiting state, the CPU is free to execute other threads that are ready to run.


4. After the specified time has elapsed, the thread scheduler moves the blocked thread back to the list of threads that are ready to execute.


5. The blocked thread is now ready to execute again, and the CPU can execute it along with other ready threads.

It’s important to note that the actual amount of time that a thread is blocked by Thread.sleep() may be longer or shorter than the specified sleep period. This is because the thread scheduler doesn’t guarantee precise timing of thread execution, and there may be other factors that affect the thread’s ability to execute, such as CPU load or other system resources.

Why Do We Use Thread.sleep() in Selenium?

In Selenium sleep, Thread.sleep() is used to add a delay between operations or to wait for an element to appear on the page. This delay can be useful in a variety of scenarios, such as:

• Waiting for page loading: Sometimes, the web page can take a while to load, and you need to wait for it to finish loading before performing any operations on it. In this case, Thread.sleep() can be used to add a delay to allow the page to finish loading.


• Waiting for element visibility: In some cases, you may need to wait for an element to become visible on the page before you can interact with it. Thread.sleep() can be used to wait for the element to appear on the page.


• Waiting for element interaction: Sometimes, you need to wait for an element to be interactable before you can click on it or perform any other operation on it. In this case, Thread.sleep() can be used to add a delay to allow the element to become interactable.

How to use Thread.sleep() in Selenium test automation?

To use the Thread.sleep() method in Java, you need to have a Java program with at least one thread. The Thread.sleep() method is used to pause the execution of a thread for a specified amount of time.

Snippet Code:

Alternatives to Thread.sleep().

1. Implicit waits: Implicit waits are used to tell Selenium to wait for a certain amount of time before throwing a “NoSuchElementException”. Implicit waits are set once and will be in effect for the entire duration of your test script.

Syntax:

This code will set the implicit wait time to 10 seconds. If the element is not found within 10 seconds, a    “NoSuchElementException” will be thrown.

2. Explicit waits: Explicit waits are used to tell Selenium to wait for a certain condition to occur before moving on to the next step in your script. You can specify the maximum amount of time to wait, and the condition that must be met.

Syntax:

This code will wait up to 10 seconds for the element with the ID “someid” to be clickable. Once the element is clickable, it will be returned and you can interact with it.

3. Fluent waits: Fluent waits are similar to explicit waits, but they allow you to chain together multiple conditions that must be met before moving on to the next step in your script.

Syntax:

Limitation of Thread.sleep().

There are several limitations of using Thread.sleep() in your code:

• Fixed wait time: When you use Thread.sleep(), you are specifying a fixed wait time, which means your code will wait for that exact amount of time before moving on to the next step, regardless of whether the operation it is waiting for has actually finished. This can cause your code to waste time waiting for something that has already been completed, or to move on before an operation has finished.


• Inaccurate timing: The Thread.sleep() method can be inaccurate, as the time it waits can be affected by external factors such as the performance of the machine running the code or other processes that are running at the same time.


• Hard to maintain: When you use Thread.sleep(), it can be difficult to maintain your code over time, as you may need to adjust the wait times based on changes to your application or system performance. This can make your code harder to read and understand.


• Potential for race conditions: Using Thread.sleep() can also create potential race conditions in your code, where one thread is waiting for a certain amount of time while another thread is attempting to perform an operation that the first thread is waiting for. This can cause unexpected behavior and bugs in your code.

Conclusion

Waits play a significant role in test automation. The Cost of maintenance becomes a challenge without using correct waiting techniques. In the above article, we have advantages and disadvantages for Thread.sleep().

Thread.sleep() has its own limitation. Waits like implicit and explicit waits are more precise and maintainable than Thread.sleep(), as they allow you to specify the maximum amount of time to wait, and the condition that must be met.

Waits like implicit and explicit waits are more precise and maintainable than Thread.sleep(), as they allow you to specify the maximum amount of time to wait, and the condition that must be met

A new approach to Test Automation

While Selenium is an open source and free tool for automating your cross browser tests, it also requires coding expertise. There might be times when you need a tool that would let you do all you do in Selenium, without the need of any coding experience. At such times you can use Testsigma, a no-code test automation tool that is open source too. With Testsigma, You can automate your tests for web, mobile, APIs and desktops from the same place. Not only that, you can start automating your test cases with Testsigma, from day 1.

Get Testsigma Open Source Here

Frequently Asked Questions:

What is the alternative for thread sleep in Selenium?

In Selenium, there are several alternatives to using Thread.sleep() to pause the execution of your test script for a specific amount of time:

1. Implicit Wait
2. Explicit Wait
3. Fluent Wait.