You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pulsar.apache.org by lh...@apache.org on 2026/09/14 14:18:17 UTC
(pulsar) 15/17: [fix] Fix cursor deadlock when skipping non-recoverable entries during mark-delete persistence (#26570)
This is an automated email from the ASF dual-hosted git repository.
lhotari pushed a commit to branch branch-4.0
in repository https://gitbox.apache.org/repos/asf/pulsar.git
commit f6a927ee428419880f752d0ad5f93c36b7a8156c
Author: void-ptr974 <vo...@protonmail.com>
AuthorDate: Mon Sep 14 08:43:11 2026 +0800
[fix] Fix cursor deadlock when skipping non-recoverable entries during mark-delete persistence (#26570)
(cherry picked from commit f613b16fe4a4507cc61f7d26c552e42b6da7eef2)
---
.../bookkeeper/mledger/impl/ManagedCursorImpl.java | 37 +++++++++------------
.../bookkeeper/mledger/impl/ManagedCursorTest.java | 38 ++++++++++++++++++++++
2 files changed, 53 insertions(+), 22 deletions(-)
diff --git a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
index 450d7fe385c8..7a08f6bdbc57 100644
--- a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
+++ b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
@@ -3157,7 +3157,7 @@ public class ManagedCursorImpl implements ManagedCursor {
* Manually acknowledge all entries from startPosition to endPosition.
* - Since this is an uncommon event, we focus on maintainability. So we do not modify
* {@link #individualDeletedMessages} and {@link #batchDeletedIndexes}, but call
- * {@link #asyncDelete(Position, AsyncCallbacks.DeleteCallback, Object)}.
+ * {@link #asyncDelete(Iterable, AsyncCallbacks.DeleteCallback, Object)}.
* - This method is valid regardless of the consumer ACK type.
* - If there is a consumer ack request after this event, it will also work.
*/
@@ -3174,31 +3174,24 @@ public class ManagedCursorImpl implements ManagedCursor {
return;
}
- lock.writeLock().lock();
log.warn("[{}] [{}] Since these entry for ledger [{}] is lost and the autoSkipNonRecoverableData is true, "
+ "these entries [{}:{}) will be auto acknowledge in subscription",
ledger.getName(), name, ledgerId, startEntryId, endEntryId);
- try {
- for (long i = startEntryId; i < endEntryId; i++) {
- if (!individualDeletedMessages.contains(ledgerId, i)) {
- asyncDelete(PositionFactory.create(ledgerId, i), new AsyncCallbacks.DeleteCallback() {
- @Override
- public void deleteComplete(Object ctx) {
- // ignore.
- }
+ asyncDelete(() -> LongStream.range(startEntryId, endEntryId)
+ .mapToObj(i -> PositionFactory.create(ledgerId, i)).iterator(),
+ new AsyncCallbacks.DeleteCallback() {
+ @Override
+ public void deleteComplete(Object ctx) {
+ // ignore.
+ }
- @Override
- public void deleteFailed(ManagedLedgerException ex, Object ctx) {
- // The method internalMarkDelete already handled the failure operation. We only need to
- // make sure the memory state is updated.
- // If the broker crashed, the non-recoverable ledger will be detected again.
- }
- }, null);
- }
- }
- } finally {
- lock.writeLock().unlock();
- }
+ @Override
+ public void deleteFailed(ManagedLedgerException ex, Object ctx) {
+ // The method internalMarkDelete already handled the failure operation. We only need to
+ // make sure the memory state is updated.
+ // If the broker crashed, the non-recoverable ledger will be detected again.
+ }
+ }, null);
}
// //////////////////////////////////////////////////
diff --git a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
index 6bdfb9054f0a..e03f863151a7 100644
--- a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
+++ b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/ManagedCursorTest.java
@@ -5627,6 +5627,44 @@ public class ManagedCursorTest extends MockedBookKeeperTestCase {
ledger.close();
}
+ @Test(timeOut = 20000)
+ public void testSkipNonRecoverableEntriesDoesNotHoldCursorLockWhilePersisting() throws Exception {
+ ManagedLedger ledger = factory.open("testSkipNonRecoverableEntriesDoesNotHoldCursorLockWhilePersisting",
+ new ManagedLedgerConfig());
+ ManagedCursorImpl cursor = (ManagedCursorImpl) ledger.openCursor("my-cursor");
+ Position firstPosition = ledger.addEntry("entry-0".getBytes(Encoding));
+ Position nextPosition = ledger.addEntry("entry-1".getBytes(Encoding));
+
+ AtomicBoolean readLockAvailable = new AtomicBoolean();
+ Thread skipThread = new Thread(
+ () -> cursor.skipNonRecoverableEntries(firstPosition, nextPosition),
+ "skip-non-recoverable-entries");
+ synchronized (cursor.pendingMarkDeleteOps) {
+ skipThread.start();
+ Awaitility.await().atMost(Duration.ofSeconds(5))
+ .until(() -> skipThread.getState() == Thread.State.BLOCKED
+ && Arrays.stream(skipThread.getStackTrace())
+ .anyMatch(frame -> frame.getMethodName().equals("internalAsyncMarkDelete")));
+ if (cursor.lock.readLock().tryLock()) {
+ try {
+ readLockAvailable.set(true);
+ } finally {
+ cursor.lock.readLock().unlock();
+ }
+ }
+ }
+
+ skipThread.join(TimeUnit.SECONDS.toMillis(5));
+ assertFalse(skipThread.isAlive(), "skip thread did not finish");
+ Awaitility.await().atMost(Duration.ofSeconds(5))
+ .until(() -> cursor.getStats().getPersistLedgerSucceed() > 0);
+ assertTrue(readLockAvailable.get(),
+ "skipNonRecoverableEntries must not hold the cursor lock while waiting to persist mark-delete");
+
+ cursor.close();
+ ledger.close();
+ }
+
@Test
public void testRecoverCursorWithTerminateManagedLedger() throws Exception {
String mlName = "my_test_ledger";