```

</details>

## What is a Container { #what-is-a-container }

Containers (mainly Linux containers) are a very **lightweight** way to package applications including all their dependencies and necessary files while keeping them isolated from other containers (other applications or components) in the same system.

        while (iter.hasNext()) {
            final SmbSessionImpl ssn = iter.next();
            if (ssn.matches(tf, targetHost, targetDomain)) {
                if (log.isTraceEnabled()) {
                    log.trace("Reusing existing session " + ssn);
                }
                return ssn.acquire();
            }
            if (log.isTraceEnabled()) {

        do {
          int shift = min(remainingPowersOf2, Long.numberOfLeadingZeros(a));
          // shift is either the number of powers of 2 left to multiply a by, or the biggest shift
          // possible while keeping a in an unsigned long.
          a = UnsignedLongs.remainder(a << shift, m);
          remainingPowersOf2 -= shift;
        } while (remainingPowersOf2 > 0);
        return a;
      }

      @Override

	if err != nil {
		return PartInfo{}, err
	}

	ctx = plkctx.Context()
	defer partIDLock.Unlock(plkctx)

	// Read lock for upload id, only held while reading the upload metadata.
	uploadIDRLock := er.NewNSLock(bucket, pathJoin(object, uploadID))
	rlkctx, err := uploadIDRLock.GetRLock(ctx, globalOperationTimeout)
	if err != nil {
		return PartInfo{}, err
	}

labels.lang=Idioma
labels.outputs=Salidas
labels.pos=Parte de la oración
labels.purgeJobLogDay=Eliminar registros de trabajos anteriores
labels.purgeUserInfoDay=Eliminar registros de usuarios anteriores
labels.reading=Lectura
labels.roleTypeIds=ID de rol
labels.scriptData=Script
labels.scriptResult=Resultado
labels.scriptType=Tipo de ejecución
labels.segmentation=Segmentación
labels.startTime=Hora de inicio

labels.jobLogging=로깅
labels.jobName=이름
labels.jobStatus=상태
labels.labelTypeIds=라벨
labels.lang=언어
labels.outputs=대상
labels.pos=품사
labels.purgeJobLogDay=이전 작업 로그 삭제
labels.purgeUserInfoDay=이전 이용자 로그 삭제
labels.reading=읽기
labels.roleTypeIds=역할 ID
labels.scriptData=스크립트
labels.scriptResult=결과
labels.scriptType=실행 방법
labels.segmentation=분할
labels.startTime=시작 시간
labels.target=대상
labels.token=토큰

<p>
That is, the compiler must not rewrite the program into this one:
</p>

<pre>
*p = 2
if !cond {
	*p = 1
}
</pre>

<p>
If <code>cond</code> is false and another goroutine is reading <code>*p</code>,
then in the original program, the other goroutine can only observe any prior value of <code>*p</code> and <code>1</code>.

      /*
       * requireNonNull is safe because we accepted an Iterable of non-null Future instances, and we
       * don't overwrite an element in the array until after reading it.
       */
      ListenableFuture<? extends T> inputFuture = requireNonNull(inputFutures[inputFutureIndex]);
      // Null out our reference to this future, so it can be GCed

			return &GetObjectReader{
				ObjInfo: objInfo,
			}, toObjectErr(errMethodNotAllowed, bucket, object)
		}
		return nil, err
	}

	// check preconditions before reading the stream.
	if checkPrecondFn != nil && checkPrecondFn(objInfo) {
		return nil, PreConditionFailed{}
	}

	opts.NoLock = true
	gr, err = z.serverPools[zIdx].GetObjectNInfo(ctx, bucket, object, rs, h, opts)

	// is too large we are basically just thrashing the CPU D-cache.
	// So if the result length is larger than an empirically-found
	// limit (8KB), we stop growing the source string once the limit
	// is reached and keep reusing the same source string - that
	// should therefore be always resident in the L1 cache - until we
	// have completed the construction of the result.
	// This yields significant speedups (up to +100%) in cases where