* </ul>
 *
 * <h4>{@link java.util.concurrent.CompletableFuture} / {@link java.util.concurrent.CompletionStage}
 * </h4>
 *
 * <p>Users of {@code CompletableFuture} will likely want to continue using {@code
 * CompletableFuture}. {@code FluentFuture} is targeted at people who use {@code ListenableFuture},
 * who can't use Java 8, or who want an API more focused than {@code CompletableFuture}. (If you

        // Stop all async notification tasks first
        List<CompletableFuture<Void>> taskFutures = new ArrayList<>(asyncNotifyTasks.values());
        for (CompletableFuture<Void> task : taskFutures) {
            task.cancel(true);
        }
        asyncNotifyTasks.clear();

        // Unregister all active registrations
        List<CompletableFuture<Void>> unregisterFutures = new ArrayList<>();

    }
    
    public CompletableFuture<WitnessRegistration> registerForNotifications(
            String shareName, 
            InetAddress serverAddress,
            WitnessNotificationListener listener) {
        
        return CompletableFuture.supplyAsync(() -> {
            try {
                // Create registration

         */
        public CompletableFuture<Void> getNotificationFuture() {
            return notificationFuture;
        }

        /**
         * Sets the future for asynchronous notification completion
         * @param future the notification future to set
         */
        public void setNotificationFuture(CompletableFuture<Void> future) {
            this.notificationFuture = future;

import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.InetAddress;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

        this.retryDelay = 1000;  // 1 second
    }
    
    public CompletableFuture<SmbFile> reconnectHandle(SmbFile file, Exception cause) {
        String path = file.getPath();
        HandleInfo info = handleManager.getHandleForReconnect(path);
        
        if (info == null) {
            return CompletableFuture.failedFuture(
                new IOException("No durable handle available for reconnection"));

        // Use default timeout if not specified or invalid
        if (timeoutSeconds <= 0) {
            timeoutSeconds = DEFAULT_LEASE_BREAK_TIMEOUT;
        }

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            handleLeaseBreak(key, newState);
        });

        try {
            future.get(timeoutSeconds, TimeUnit.SECONDS);
        } catch (TimeoutException e) {

    int chunkSize = length / channelCount;
    List<CompletableFuture<Void>> futures = new ArrayList<>();
    
    for (int i = 0; i < channelCount; i++) {
        final int chunkOffset = i * chunkSize;
        final int chunkLength = (i == channelCount - 1) ? 
            length - chunkOffset : chunkSize;
        final ChannelInfo channel = channels.get(i);
        
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {

- Optimize lease break acknowledgment timing

## 10. Error Handling

### 10.1 Lease Break Timeout
```java
public void handleLeaseBreakWithTimeout(Smb2LeaseKey key, int newState) {
    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
        handleLeaseBreak(key, newState);
    });
    
    try {
        future.get(5, TimeUnit.SECONDS);  // 5 second timeout
    } catch (TimeoutException e) {

            // Cancel any pending notifications
            cancelNotification(handle);
        }
    }
    
    private void startAsyncNotification(ChangeNotificationHandle handle) {
        CompletableFuture.runAsync(() -> {
            while (handle.active) {
                try {
                    // Send SMB2 Change Notify request
                    Smb2ChangeNotifyRequest request = new Smb2ChangeNotifyRequest();