*
     * @return active connection count
     */
    public long getConnectionsActive() {
        return connectionsActive.get();
    }

    /**
     * Get total number of memory regions allocated
     *
     * @return memory region count
     */
    public long getMemoryRegionsAllocated() {
        return memoryRegionsAllocated.get();
    }

    /**

            cleanupExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Log final statistics
        log.info("ResourceManager shutdown complete. Total allocated: {}, released: {}, leaks: {}, force cleaned: {}", totalAllocated.get(),
                totalReleased.get(), totalLeaks.get(), cleaned);
    }

    /**
     * Create a managed resource wrapper
     *

        for (int i = methods.length; i-- > 0; ) {
            methodInfos[i] = new MethodInfo(methods[i]);
        }

        int upcastCount = getAccessibleMethods(clazz, methodInfos, 0);

        // Reallocate array in case some method had no accessible counterpart.
        if (upcastCount < methods.length) {
            methods = new Method[upcastCount];
        }

        int j = 0;

            }

            final ByteBuffer buffer = ByteBuffer.allocate((int) fileSize);
            ChannelUtil.read(channel, buffer);
            return buffer.array();
        } finally {
            CloseableUtil.close(is);
        }
    }

    /**

            throw new SmbException("Invalid command code: " + command);
        }
    }

    /**
     * Validate array size before allocation
     *
     * @param size array size to allocate
     * @param elementSize size of each element
     * @param maxElements maximum allowed elements
     * @throws SmbException if allocation would be too large
     */

  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue
  int allocArrays() {
    Preconditions.checkState(needsAllocArrays(), "Arrays already allocated");

    int expectedSize = metadata;
    int buckets = CompactHashing.tableSize(expectedSize);

      File file = getFile();
      Reader reader = new InputStreamReader(new FileInputStream(file), UTF_8);
      StringBuilder builder = new StringBuilder();
      CharBuffer buffer = CharBuffer.allocate(100);
      while (reader.read(buffer) != -1) {
        Java8Compatibility.flip(buffer);
        builder.append(buffer);
        Java8Compatibility.clear(buffer);
      }
      return builder.toString();
    }

        }
        return result;
    }

    /**
     * Converts the list to an array.
     *
     * @param array the array to store the elements. A new array of the same runtime type is allocated if the array is not large enough.
     * @return the array
     */
    @SuppressWarnings("unchecked")
    public E[] toArray(E[] array) {
        if (array.length < size) {

            new ArrayBlockingQueue<Runnable>(1000));
    executorService.prestartAllCoreThreads();
    AtomicInteger integer = new AtomicInteger();
    // Execute a bunch of tasks to ensure that our threads are allocated and hot
    for (int i = 0; i < NUM_THREADS * 10; i++) {
      @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
      Future<?> possiblyIgnoredError =

holding the C pointers and use runtime.SetFinalizer on those Go objects.

It is much more difficult for the C world to have pointers into the Go
world, because the Go garbage collector is unaware of the memory
allocated by C.  The most important consideration is not to
constrain future implementations, so the rule is that Go code can
hand a Go pointer to C code but must separately arrange for