cacheStmt := &Stmt{
		Transaction: isTransaction,
		prepared:    make(chan struct{}),
	}
	// Cache the Stmt object with the associated key.
	s.Set(key, cacheStmt)
	// Unlock after completing initialization to prevent deadlocks.
	locker.Unlock()

	// Ensure the prepared channel is closed after the function execution completes.
	defer close(cacheStmt.prepared)

	// Prepare the SQL statement using the provided connection.

		return err
	}
	defer lock.Unlock(lkCtx)

	ctx = lkCtx.Context()
	noLockOpts := ObjectOptions{NoLock: true}
	r := &rebalanceMeta{}
	err = r.loadWithOpts(ctx, z.serverPools[0], noLockOpts)
	if err != nil && !errors.Is(err, errConfigNotFound) {
		return err
	}

	z.rebalMu.Lock()
	defer z.rebalMu.Unlock()

	// if not found, we store the memory metadata back

		}(w)
	}
	select{}
}
</pre>

<h3 id="locks">Locks</h3>

<p>
The <code>sync</code> package implements two lock data types,
<code>sync.Mutex</code> and <code>sync.RWMutex</code>.
</p>

<p class="rule">
For any <code>sync.Mutex</code> or <code>sync.RWMutex</code> variable <code>l</code> and <i>n</i> &lt; <i>m</i>,

		debug.PrintStack()
		return metacache{}
	}

	// Grab a write lock, since we create one if we cannot find one.
	b.mu.Lock()
	defer b.mu.Unlock()

	// Check if exists already.
	if c, ok := b.caches[o.ID]; ok {
		c.lastHandout = time.Now()
		b.caches[o.ID] = c
		b.debugf("returning existing %v", o.ID)
		return c
	}

	if !o.Create {

    }
}
```

### 4.3 Lease Manager
```java
package jcifs.internal.smb2.lease;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import jcifs.CIFSContext;

public class LeaseManager {
    private final ConcurrentHashMap<Smb2LeaseKey, LeaseEntry> leases;

        log.debug("Cleaned up rate limiter entries. Accounts: {}, IPs: {}", accountAttempts.size(), ipAttempts.size());
    }

    /**
     * Manually unlock an account
     *
     * @param username the username to unlock
     * @return true if account was unlocked, false if not found
     */
    public boolean unlockAccount(String username) {
        AccountAttempts account = accountAttempts.get(username);

	return &targetsList{}
}

func (tl *targetsList) get() []Target {
	tl.mu.RLock()
	defer tl.mu.RUnlock()

	return tl.list
}

func (tl *targetsList) add(t Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = append(tl.list, t)
}

func (tl *targetsList) set(tgts []Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = tgts
}

var (

	// systemTargets is the set of enabled loggers.

func (c *Config) Registered() bool {
	configLock.RLock()
	defer configLock.RUnlock()

	return len(c.APIKey) > 0
}

// ApplyEnv - applies the current subnet config to Console UI specific environment variables.
func (c *Config) ApplyEnv() {
	configLock.RLock()
	defer configLock.RUnlock()

	if c.License != "" {
		os.Setenv("CONSOLE_SUBNET_LICENSE", c.License)
	}
	if c.APIKey != "" {

func (opts Config) GetWorkers() int {
	configMutex.RLock()
	defer configMutex.RUnlock()
	return opts.DriveWorkers
}

// Update updates opts with nopts
func (opts *Config) Update(nopts Config) {
	configMutex.Lock()
	defer configMutex.Unlock()

	opts.Bitrot = nopts.Bitrot
	opts.IOCount = nopts.IOCount
	opts.Sleep = nopts.Sleep
	opts.DriveWorkers = nopts.DriveWorkers

	opts.cache.bitrotCycle, _ = parseBitrotConfig(nopts.Bitrot)
}

				if globalIsDistErasure {
					globalLocalSetDrives[s.poolIndex][setIndex][diskIndex] = disk
				}
				globalLocalDrivesMap[disk.Endpoint().String()] = disk
				globalLocalDrivesMu.Unlock()
			}
			s.erasureDisksMu.Unlock()
		}(endpoint)
	}

	wg.Wait()
}

// monitorAndConnectEndpoints this is a monitoring loop to keep track of disconnected