import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
public CreateBatchUser(@PluginName String pluginName, SchemaFactory<ReviewDb> schema,
					   PluginConfigFactory configFactory, SshKeyCache sshKeyCache, VersionedAuthorizedKeys.Accessor authorizedKeys,
					   AccountCache accountCache, AccountByEmailCache byEmailCache, AccountLoader.Factory infoLoader,
					   GroupsCollection groupsCollection, WorkQueue queue, ThreadLocalRequestContext context,
					   IdentifiedUser.GenericFactory userFactory) {
	this.schema = schema;
	this.sshKeyCache = sshKeyCache;
	this.authorizedKeys = authorizedKeys;
	this.accountCache = accountCache;
	this.byEmailCache = byEmailCache;
	this.infoLoader = infoLoader;
	this.groupsCollection = groupsCollection;
	this.context = context;
	this.userFactory = userFactory;
	pluginConfig = configFactory.getFromGerritConfig(pluginName);
	username = pluginConfig.getString("username", "jenkins");
	sshKey = pluginConfig.getString("sshKey");
	name = pluginConfig.getString("name", "Batch user");
	executor = queue.getDefaultQueue();

	createBatchUserIfNotExistsYet();
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
protected PushAll(
    WorkQueue wq,
    ProjectCache projectCache,
    ReplicationQueue rq,
    ReplicationStateListener stateLog,
    @Assisted @Nullable String urlMatch,
    @Assisted ReplicationFilter filter,
    @Assisted ReplicationState state,
    @Assisted boolean now) {
  this.workQueue = wq;
  this.projectCache = projectCache;
  this.replication = rq;
  this.stateLog = stateLog;
  this.urlMatch = urlMatch;
  this.filter = filter;
  this.state = state;
  this.now = now;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
public CommandExecutorQueueProvider(
    @GerritServerConfig Config config,
    ThreadSettingsConfig threadsSettingsConfig,
    WorkQueue queues) {
  poolSize = threadsSettingsConfig.getSshdThreads();
  batchThreads =
      config.getInt("sshd", "batchThreads", threadsSettingsConfig.getSshdBatchTreads());
  if (batchThreads > poolSize) {
    poolSize += batchThreads;
  }
  int interactiveThreads = Math.max(1, poolSize - batchThreads);
  interactiveExecutor =
      queues.createQueue(interactiveThreads, "SSH-Interactive-Worker", Thread.MIN_PRIORITY);
  if (batchThreads != 0) {
    batchExecutor = queues.createQueue(batchThreads, "SSH-Batch-Worker", Thread.MIN_PRIORITY);
  } else {
    batchExecutor = interactiveExecutor;
  }
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
CommandFactoryProvider(
    @CommandName(Commands.ROOT) DispatchCommandProvider d,
    @GerritServerConfig Config cfg,
    WorkQueue workQueue,
    SshLog l,
    SshScope s,
    SchemaFactory<ReviewDb> sf) {
  dispatcher = d;
  log = l;
  sshScope = s;
  schemaFactory = sf;

  int threads = cfg.getInt("sshd", "commandStartThreads", 2);
  startExecutor = workQueue.createQueue(threads, "SshCommandStart");
  destroyExecutor =
      Executors.newSingleThreadExecutor(
          new ThreadFactoryBuilder()
              .setNameFormat("SshCommandDestroy-%s")
              .setDaemon(true)
              .build());
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
private Response.Accepted applyAsync(Project.NameKey project, Input input) {
  Runnable job =
      new Runnable() {
        @Override
        public void run() {
          runGC(project, input, null);
        }

        @Override
        public String toString() {
          return "Run "
              + (input.aggressive ? "aggressive " : "")
              + "garbage collection on project "
              + project.get();
        }
      };

  @SuppressWarnings("unchecked")
  WorkQueue.Task<Void> task = (WorkQueue.Task<Void>) workQueue.getDefaultQueue().submit(job);

  String location =
      canonicalUrl.get() + "a/config/server/tasks/" + IdGenerator.format(task.getTaskId());

  return Response.accepted(location);
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
ReviewerRecommender(
    ChangeQueryBuilder changeQueryBuilder,
    DynamicMap<ReviewerSuggestion> reviewerSuggestionPluginMap,
    Provider<InternalChangeQuery> queryProvider,
    WorkQueue workQueue,
    Provider<ReviewDb> dbProvider,
    ApprovalsUtil approvalsUtil,
    @GerritServerConfig Config config) {
  Set<FillOptions> fillOptions = EnumSet.of(FillOptions.SECONDARY_EMAILS);
  fillOptions.addAll(AccountLoader.DETAILED_OPTIONS);
  this.changeQueryBuilder = changeQueryBuilder;
  this.config = config;
  this.queryProvider = queryProvider;
  this.reviewerSuggestionPluginMap = reviewerSuggestionPluginMap;
  this.workQueue = workQueue;
  this.dbProvider = dbProvider;
  this.approvalsUtil = approvalsUtil;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Provides
@Singleton
@IndexExecutor(INTERACTIVE)
ListeningExecutorService getInteractiveIndexExecutor(
    @GerritServerConfig Config config, WorkQueue workQueue) {
  if (interactiveExecutor != null) {
    return interactiveExecutor;
  }
  int threads = this.threads;
  if (threads <= 0) {
    threads = config.getInt("index", null, "threads", 0);
  }
  if (threads <= 0) {
    threads = Runtime.getRuntime().availableProcessors() / 2 + 1;
  }
  return MoreExecutors.listeningDecorator(workQueue.createQueue(threads, "Index-Interactive"));
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
ChangeUpdatedListener(final SmartReviewers.Factory smartReviewersFactory,
    final GitRepositoryManager repoManager, final WorkQueue workQueue,
    final IdentifiedUser.GenericFactory identifiedUserFactory,
    final ThreadLocalRequestContext tl,
    final SchemaFactory<ReviewDb> schemaFactory,
    final PluginConfigFactory cfg,
    final @PluginName String pluginName) {
  this.smartReviewersFactory = smartReviewersFactory;
  this.repoManager = repoManager;
  this.workQueue = workQueue;
  this.identifiedUserFactory = identifiedUserFactory;
  this.tl = tl;
  this.schemaFactory = schemaFactory;
  this.cfg = cfg;
  this.pluginName = pluginName;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
public UserEventWorker(
    ChangeHooks hooks,
    WorkQueue workQueue,
    AccountResolver accountResolver,
    IdentifiedUser.GenericFactory userFactory,
    ThreadLocalRequestContext threadLocalRequestContext,
    PluginUser pluginUser,
    SchemaFactory<ReviewDb> schemaFactory) {
  this.hooks = hooks;
  this.workQueue = workQueue;
  this.accountResolver = accountResolver;
  this.userFactory = userFactory;
  this.threadLocalRequestContext = threadLocalRequestContext;
  this.pluginUser = pluginUser;
  this.schemaFactory = schemaFactory;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
public AutoReloadConfigDecorator(
    SitePaths site, WorkQueue workQueue, DestinationFactory destinationFactory)
    throws ConfigInvalidException, IOException {
  this.site = site;
  this.destinationFactory = destinationFactory;
  this.currentConfig = loadConfig();
  this.currentConfigTs = getLastModified(currentConfig);
  this.workQueue = workQueue;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
ReplicationQueue(
    WorkQueue wq,
    SshHelper sh,
    GerritSshApi ga,
    ReplicationConfig rc,
    DynamicItem<EventDispatcher> dis,
    ReplicationStateListener sl) {
  workQueue = wq;
  sshHelper = sh;
  dispatcher = dis;
  config = rc;
  stateLog = sl;
  gerritAdmin = ga;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
GarbageCollect(
    GitRepositoryManager repoManager,
    GarbageCollection.Factory garbageCollectionFactory,
    WorkQueue workQueue,
    @CanonicalWebUrl Provider<String> canonicalUrl) {
  this.workQueue = workQueue;
  this.canonicalUrl = canonicalUrl;
  this.canGC = repoManager instanceof LocalDiskRepositoryManager;
  this.garbageCollectionFactory = garbageCollectionFactory;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Provides
@Singleton
@ReceiveCommitsExecutor
public ExecutorService createReceiveCommitsExecutor(
    @GerritServerConfig Config config, WorkQueue queues) {
  int poolSize =
      config.getInt(
          "receive", null, "threadPoolSize", Runtime.getRuntime().availableProcessors());
  return queues.createQueue(poolSize, "ReceiveCommits");
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Provides
@Singleton
@SendEmailExecutor
public ExecutorService createSendEmailExecutor(
    @GerritServerConfig Config config, WorkQueue queues) {
  int poolSize = config.getInt("sendemail", null, "threadPoolSize", 1);
  if (poolSize == 0) {
    return MoreExecutors.newDirectExecutorService();
  }
  return queues.createQueue(poolSize, "SendEmail");
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
Builder(
    GerritServerConfigProvider configProvider,
    SitePaths sitePaths,
    SchemaFactory<ReviewDb> schemaFactory,
    GitRepositoryManager repoManager,
    NoteDbUpdateManager.Factory updateManagerFactory,
    ChangeBundleReader bundleReader,
    AllProjectsName allProjects,
    ThreadLocalRequestContext requestContext,
    InternalUser.Factory userFactory,
    ChangeRebuilderImpl rebuilder,
    WorkQueue workQueue,
    MutableNotesMigration globalNotesMigration,
    PrimaryStorageMigrator primaryStorageMigrator,
    DynamicSet<NotesMigrationStateListener> listeners) {
  // Reload gerrit.config/notedb.config on each migrator invocation, in case a previous
  // migration in the same process modified the on-disk contents. This ensures the defaults for
  // trial/autoMigrate get set correctly below.
  this.cfg = configProvider.get();
  this.sitePaths = sitePaths;
  this.schemaFactory = schemaFactory;
  this.repoManager = repoManager;
  this.updateManagerFactory = updateManagerFactory;
  this.bundleReader = bundleReader;
  this.allProjects = allProjects;
  this.requestContext = requestContext;
  this.userFactory = userFactory;
  this.rebuilder = rebuilder;
  this.workQueue = workQueue;
  this.globalNotesMigration = globalNotesMigration;
  this.primaryStorageMigrator = primaryStorageMigrator;
  this.listeners = listeners;
  this.trial = getTrialMode(cfg);
  this.autoMigrate = getAutoMigrate(cfg);
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Provides
@Singleton
@IndexExecutor(BATCH)
ListeningExecutorService getBatchIndexExecutor(
    @GerritServerConfig Config config, WorkQueue workQueue) {
  if (batchExecutor != null) {
    return batchExecutor;
  }
  int threads = config.getInt("index", null, "batchThreads", 0);
  if (threads <= 0) {
    threads = Runtime.getRuntime().availableProcessors();
  }
  return MoreExecutors.listeningDecorator(workQueue.createQueue(threads, "Index-Batch"));
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
Lifecycle(WorkQueue queue, AccountDeactivator deactivator, @GerritServerConfig Config cfg) {
  this.queue = queue;
  this.deactivator = deactivator;
  scheduleConfig = new ScheduleConfig(cfg, "accountDeactivation");
  supportAutomaticAccountActivityUpdate =
      cfg.getBoolean("auth", "autoUpdateAccountActiveStatus", false);
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
public ListTasks(
    PermissionBackend permissionBackend, WorkQueue workQueue, Provider<CurrentUser> self) {
  this.permissionBackend = permissionBackend;
  this.workQueue = workQueue;
  this.self = self;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
@Inject
TasksCollection(
    DynamicMap<RestView<TaskResource>> views,
    ListTasks list,
    WorkQueue workQueue,
    Provider<CurrentUser> self,
    PermissionBackend permissionBackend) {
  this.views = views;
  this.list = list;
  this.workQueue = workQueue;
  this.self = self;
  this.permissionBackend = permissionBackend;
}
 

import com.google.gerrit.server.git.WorkQueue; //导入依赖的package包/类
private void waitForEmails() {
  // TODO(dborowitz): This is brittle; consider forcing emails to use
  // a single thread in tests (tricky because most callers just use the
  // default executor).
  for (WorkQueue.Task<?> task : workQueue.getTasks()) {
    if (task.toString().contains("send-email")) {
      try {
        task.get();
      } catch (ExecutionException | InterruptedException e) {
        log.warn("error finishing email task", e);
      }
    }
  }
}