fix(locks): handle retry_interval=0 without jitter errors

Author: cabol

CHANGELOG.md

@@ -19,6 +19,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   removal of the default transaction implementation from Nebulex core, allowing
   adapters to provide implementations tailored to their specific needs.
   [#7](https://github.com/elixir-nebulex/nebulex_local/issues/7).
+- [Nebulex.Locks] Improved retry behavior when `:retry_interval` is `0` by
+  handling immediate retries without jitter. This prevents errors during lock
+  acquisition retries and keeps zero-delay retry strategies working as expected.
 
 ## [v3.0.0-rc.2](https://github.com/elixir-nebulex/nebulex_local/tree/v3.0.0-rc.2) (2025-12-07)
 > [Full Changelog](https://github.com/elixir-nebulex/nebulex_local/compare/v3.0.0-rc.1...v3.0.0-rc.2)

lib/nebulex/locks.ex

@@ -252,6 +252,10 @@ defmodule Nebulex.Locks do
   This function is typically called in an `after` block to ensure
   locks are released even if an exception occurs.
 
+  This API assumes trusted callers: it does not verify lock ownership
+  when deleting lock entries. Releasing keys not owned by the current
+  process is considered undefined behavior.
+
   The first parameter can be either a named table (atom) or a table reference.
 
   ## Examples
@@ -474,8 +478,12 @@ defmodule Nebulex.Locks do
     end
   end
 
-  # Sleep with random jitter to prevent thundering herd (integer or :infinity)
-  defp sleep_with_jitter(interval, _attempt) do
+  # Sleep with random jitter to prevent thundering herd (fixed interval)
+  defp sleep_with_jitter(0, _attempt) do
+    :ok
+  end
+
+  defp sleep_with_jitter(interval, _attempt) when is_integer(interval) and interval > 0 do
     jitter = :rand.uniform(interval)
     sleep_time = interval + jitter
 

lib/nebulex/locks/options.ex

@@ -85,20 +85,18 @@ defmodule Nebulex.Locks.Options do
       """
     ],
     retry_interval: [
-      type: {:or, [:timeout, {:fun, 1}]},
-      type_doc: "`t:timeout/0` | `(attempt :: non_neg_integer() -> timeout())`",
+      type: {:or, [:non_neg_integer, {:fun, 1}]},
+      type_doc: "`t:non_neg_integer/0` | `(attempt :: non_neg_integer() -> non_neg_integer())`",
       required: false,
       default: 10,
       doc: """
       The time in milliseconds to wait between lock acquisition retries.
 
       Can be either:
 
-        * A timeout value (`non_neg_integer()` or `:infinity`) - A fixed
-          interval. When using a non-negative integer, a small random jitter is
-          added to prevent thundering herd issues. The value `:infinity` is
-          accepted for type compatibility but not recommended (would block
-          indefinitely).
+        * A timeout value (`non_neg_integer()`) - A fixed interval. When using
+          a non-negative integer, a small random jitter is added to prevent
+          thundering herd issues.
         * An anonymous function - Receives the current attempt number
           (0-indexed) and must return a non-negative integer representing the
           interval in milliseconds. No jitter is added, giving you full control

test/nebulex/locks_test.exs

@@ -253,6 +253,17 @@ defmodule Nebulex.LocksTest do
 
       assert Locks.release(table, [:zero_retry_key]) == :ok
     end
+
+    test "retry_interval zero performs immediate retries without crashing", %{table: table} do
+      # First process locks a key
+      assert Locks.acquire(table, [:zero_interval_key]) == :ok
+
+      # Integer retry_interval: 0 should not crash and should timeout quickly
+      assert Locks.acquire(table, [:zero_interval_key], retries: 2, retry_interval: 0) ==
+               {:error, :timeout}
+
+      assert Locks.release(table, [:zero_interval_key]) == :ok
+    end
   end
 
   describe "periodic cleanup" do