* methods for more details.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access the same cell of
 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}

            case 2:
                md4.update(ntHash);
                md4.digest(dest, offset, 16);
                break;
            case 3:
            case 4:
            case 5:
                synchronized (this) {
                    if (this.clientChallenge == null) {
                        this.clientChallenge = new byte[8];
                        tc.getConfig().getRandom().nextBytes(this.clientChallenge);

     */
    protected short getSystemCpuPercent() {
        final long now = getCurrentTimeAsLong();
        if (now - systemCpuCheckTime > systemCpuCheckInterval) {
            synchronized (this) {
                if (now - systemCpuCheckTime > systemCpuCheckInterval) {
                    try {
                        final OsProbe osProbe = OsProbe.getInstance();

     * Returns the FesenClient instance, connecting if not already connected.
     * @return The FesenClient instance.
     */
    protected FesenClient getClient() {
        if (!fesenClient.connected()) {
            synchronized (fesenClient) {
                if (!fesenClient.connected()) {
                    fesenClient.connect();
                }
            }
        }
        return fesenClient;
    }

    /**

     */
    protected String trustManager;

    /**
     * Whether to enter local passive mode.
     */
    protected boolean enterLocalPassiveMode;

    @Override
    public synchronized void init() {
        if (ftpAuthenticationHolder != null) {
            return;
        }

        super.init();

            this.supplier = supplier;
        }

        @Override
        public Set<Entry<K, V>> entrySet() {
            if (delegate == null) {
                synchronized (this) {
                    if (delegate == null) {
                        delegate = supplier.get();
                    }
                }
            }
            return delegate.entrySet();

   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p>This method is safe to use even when {@code sortedMultiset} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws NullPointerException if {@code sortedMultiset} or any of its elements is null
   */

   * {@code ImmutableList.of(list)} returns an {@code ImmutableList<List<String>>} containing one
   * element (the given list itself).
   *
   * <p>This method is safe to use even when {@code elements} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws NullPointerException if {@code elements} contains a null element
   */

        }

        synchronized void write(final byte[] b, final int n, final SmbFile dest, final long off) {
            this.b = b;
            this.n = n;
            this.dest = dest;
            this.off = off;
            ready = false;
            notify();
        }

        @Override
        public void run() {
            synchronized (this) {
                try {

                        byte[] plaintext = message.getBytes();
                        long sessionId = (threadId * 1000L) + i;

                        synchronized (encrypted) {
                            byte[] encryptedData = context.encryptMessage(plaintext, sessionId);
                            messages.add(message);
                            encrypted.add(encryptedData);