*
     * @see jcifs.SmbTreeHandle#close()
     */
    @Override
    public synchronized void close() {
        release();
    }

    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire() {
        if (this.usageCount.incrementAndGet() == 1) {
            this.treeConnection.acquire();
        }
        return this;
    }

    @Override

you will have a more or less well-defined, stable, and limited amount of memory consumed by each of those containers (more than one if they are replicated).

And then you can set those same memory limits and requirements in your configurations for your container management system (for example in **Kubernetes**). That way it will be able to **replicate the containers** in the **available machines** taking into account the amount of memory needed by them, and the amount available in the machines...

	ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
	ErrBufferFull        = errors.New("bufio: buffer full")
	ErrNegativeCount     = errors.New("bufio: negative count")
)

// Buffered input.

// Reader implements buffering for an io.Reader object.
// A new Reader is created by calling [NewReader] or [NewReaderSize];

                } else {
                    // This should not happen.
                    error("Invalid projects count: $seenProjectsCount != $enabledCount + $toEnableCount + $uncheckedCount")
                }
            }
        }
    }

    private fun projectS(num: Int) = if (num == 1) "project" else "projects"

import java.util.Iterator;
import java.util.NavigableSet;
import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of the {@link SortedMultiset} interface.
 *
 * <p>The {@link #count} and {@link #size} implementations all iterate across the set returned by
 * {@link Multiset#entrySet()}, as do many methods acting on the set returned by {@link
 * #elementSet()}. Override those methods for better performance.
 *

      }
    }
  }

  private static class CountingIterable implements Iterable<String> {
    int count = 0;

    @Override
    public Iterator<String> iterator() {
      count++;
      return asList("a", "b", "a").iterator();
    }
  }

  public void testCopyOf_plainIterable() {
    CountingIterable iterable = new CountingIterable();

	for _, hash := range metaHashes {
		if hash == "" {
			continue
		}
		metaHashCountMap[hash]++
	}

	maxHash := ""
	maxCount := 0
	for hash, count := range metaHashCountMap {
		if count > maxCount {
			maxCount = count
			maxHash = hash
		}
	}

	if maxCount < quorum {
		return FileInfo{}, InsufficientReadQuorum{Err: errErasureReadQuorum, Type: RQInconsistentMeta}
	}

	peerLocks := globalNotificationSys.GetLocks(ctx, r)

	topLocks := topLockEntries(peerLocks, stale)

	// Marshal API response upto requested count.
	if len(topLocks) > count && count > 0 {
		topLocks = topLocks[:count]
	}

	jsonBytes, err := json.Marshal(topLocks)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

        // Default constructor
    }

    private static final Logger logger = LogManager.getLogger(CrawlingInfoHelper.class);

    /**
     * Key used for facet count aggregations.
     */
    public static final String FACET_COUNT_KEY = "count";

    /**
     * Map containing crawling information parameters.
     */
    protected Map<String, String> infoMap;

    /**

		// a row, then make sure we print it to call attention.
		if m[err.Error()] > 2 {
			peersLogAlwaysIf(ctx, fmt.Errorf("Following error has been printed %d times.. %w", m[err.Error()], err))
			// Reduce the count to introduce further delay in printing
			// but let it again print after the 2th attempt
			m[err.Error()]--
			m[err.Error()]--
		}
		m[err.Error()]++
	}
}()

// Cleans up tmp directory of the local disk.