}

    /**
     * Installs the specified artifact in a background thread.
     * Also removes any previously installed versions of the same plugin.
     *
     * @param artifact the artifact to install
     */
    public static void installArtifact(final Artifact artifact) {
        new Thread(() -> {
            final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();

     *
     * @param task
     *            the task to execute
     */
    public static void execute(final Runnable task) {
        ForkJoinPool.commonPool().execute(() -> {
            final Thread currentThread = Thread.currentThread();
            final ClassLoader orignal = currentThread.getContextClassLoader();
            currentThread.setContextClassLoader(CommonPoolUtil.class.getClassLoader());
            try {

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The {@code ThreadSafe} annotation can be used to indicate a given type
 * is thread safe.  {@link Immutable} objects are automatically thread safe.
 *
 * @see Immutable
 * @see NotThreadSafe
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)

 * under the License.
 */

/**
 * Provides an immutable XML processing API for Maven, offering classes and interfaces
 * for reading, manipulating, and writing XML documents in a thread-safe manner.
 * This package is used extensively for POM, settings, and other Maven configuration files.
 *
 * @since 4.0.0
 */

   * which is still better than alternatives.
   *
   * Per-thread hash codes are initialized to random values.
   * Contention and/or table collisions are indicated by failed
   * CASes when performing an update operation (see method
   * retryUpdate). Upon a collision, if the table size is less than
   * the capacity, it is doubled in size unless some other thread
   * holds the lock. If a hashed slot is empty, and lock is

    /** The next byte to read. This is always less than or equal to [upstreamPos]. */
    private var sourcePos = 0L

    /**
     * Selects where to find the bytes for a read and read them. This is one of three sources.
     *
     * ## Upstream
     *
     * In this case the current thread is assigned as the upstream reader. We read bytes from

        // Create thread pools
        this.channelExecutor = Executors.newCachedThreadPool(r -> {
            Thread t = new Thread(r, "SMB3-MultiChannel-Worker");
            t.setDaemon(true);
            return t;
        });

        this.healthCheckExecutor = Executors.newScheduledThreadPool(2, r -> {
            Thread t = new Thread(r, "SMB3-MultiChannel-HealthCheck");

 * methods that they depend on are thread-safe.
 *
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingSet<E extends @Nullable Object> extends ForwardingCollection<E>
    implements Set<E> {
  // TODO(lowasser): identify places where thread safety is actually lost

        } catch (final UnsupportedEncodingException e) {
            throw new CurlException("Invalid encoding: " + encoding, e);
        }
    }

    /**
     * Sets the thread pool for executing the request.
     *
     * @param threadPool the thread pool
     * @return this CurlRequest instance
     */
    public CurlRequest threadPool(final ForkJoinPool threadPool) {
        this.threadPool = threadPool;

 * the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.base.Preconditions.checkNotNull;
import static java.lang.Thread.currentThread;

import com.google.common.annotations.GwtCompatible;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;