Java ConcurrencyUtil类代码示例

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
@Override
public PsiClassType createTypeByFQClassName(@NotNull final String qName, @NotNull final GlobalSearchScope resolveScope) {
  if (CommonClassNames.JAVA_LANG_OBJECT.equals(qName)) {
    PsiClassType cachedObjectType = myCachedObjectType.get(resolveScope);
    if (cachedObjectType != null) {
      return cachedObjectType;
    }
    PsiClass aClass = JavaPsiFacade.getInstance(myManager.getProject()).findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
    if (aClass != null) {
      cachedObjectType = new PsiImmediateClassType(aClass, PsiSubstitutor.EMPTY);
      cachedObjectType = ConcurrencyUtil.cacheOrGet(myCachedObjectType, resolveScope, cachedObjectType);
      return cachedObjectType;
    }
  }
  return new PsiClassReferenceType(createReferenceElementByFQClassName(qName, resolveScope), null);
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Override
public PsiClass findClass(@NotNull final String qualifiedName, @NotNull GlobalSearchScope scope) {
  ProgressIndicatorProvider.checkCanceled(); // We hope this method is being called often enough to cancel daemon processes smoothly

  Map<String, PsiClass> map = myClassCache.get(scope);
  if (map == null) {
    map = ContainerUtil.createConcurrentWeakValueMap();
    map = ConcurrencyUtil.cacheOrGet(myClassCache, scope, map);
  }
  PsiClass result = map.get(qualifiedName);
  if (result == null) {
    result = doFindClass(qualifiedName, scope);
    if (result != null) {
      map.put(qualifiedName, result);
    }
  }

  return result;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Override
public PsiPackage findPackage(@NotNull String qualifiedName) {
  PsiPackage aPackage = myPackageCache.get(qualifiedName);
  if (aPackage != null) {
    return aPackage;
  }

  for (PsiElementFinder finder : filteredFinders()) {
    aPackage = finder.findPackage(qualifiedName);
    if (aPackage != null) {
      return ConcurrencyUtil.cacheOrGet(myPackageCache, qualifiedName, aPackage);
    }
  }

  return null;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
static HighlightingSession getOrCreateHighlightingSession(@NotNull PsiFile psiFile,
                                                          @Nullable Editor editor,
                                                          @NotNull DaemonProgressIndicator progressIndicator,
                                                          @Nullable EditorColorsScheme editorColorsScheme) {
  HighlightingSession session = getHighlightingSession(psiFile, progressIndicator);
  if (session == null) {
    session = new HighlightingSessionImpl(psiFile, editor, progressIndicator, editorColorsScheme);
    ConcurrentMap<PsiFile, HighlightingSession> map = progressIndicator.getUserData(HIGHLIGHTING_SESSION);
    if (map == null) {
      map = progressIndicator.putUserDataIfAbsent(HIGHLIGHTING_SESSION, ContainerUtil.<PsiFile, HighlightingSession>newConcurrentMap());
    }
    session = ConcurrencyUtil.cacheOrGet(map, psiFile, session);
  }
  return session;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
public static AttributesFlyweight create(Color foreground,
                                         Color background,
                                         @JdkConstants.FontStyle int fontType,
                                         Color effectColor,
                                         EffectType effectType,
                                         Color errorStripeColor) {
  FlyweightKey key = ourKey.get();
  if (key == null) {
    ourKey.set(key = new FlyweightKey());
  }
  key.foreground = foreground;
  key.background = background;
  key.fontType = fontType;
  key.effectColor = effectColor;
  key.effectType = effectType;
  key.errorStripeColor = errorStripeColor;

  AttributesFlyweight flyweight = entries.get(key);
  if (flyweight != null) {
    return flyweight;
  }

  AttributesFlyweight newValue = new AttributesFlyweight(foreground, background, fontType, effectColor, effectType, errorStripeColor);
  return ConcurrencyUtil.cacheOrGet(entries, key.clone(), newValue);
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Override
@NotNull
@SuppressWarnings({"unchecked"})
public <L> L syncPublisher(@NotNull final Topic<L> topic) {
  checkNotDisposed();
  L publisher = (L)mySyncPublishers.get(topic);
  if (publisher == null) {
    final Class<L> listenerClass = topic.getListenerClass();
    InvocationHandler handler = new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        sendMessage(new Message(topic, method, args));
        return NA;
      }
    };
    publisher = (L)Proxy.newProxyInstance(listenerClass.getClassLoader(), new Class[]{listenerClass}, handler);
    publisher = (L)ConcurrencyUtil.cacheOrGet(mySyncPublishers, topic, publisher);
  }
  return publisher;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Override
@NotNull
@SuppressWarnings({"unchecked"})
public <L> L asyncPublisher(@NotNull final Topic<L> topic) {
  checkNotDisposed();
  L publisher = (L)myAsyncPublishers.get(topic);
  if (publisher == null) {
    final Class<L> listenerClass = topic.getListenerClass();
    InvocationHandler handler = new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        postMessage(new Message(topic, method, args));
        return NA;
      }
    };
    publisher = (L)Proxy.newProxyInstance(listenerClass.getClassLoader(), new Class[]{listenerClass}, handler);
    publisher = (L)ConcurrencyUtil.cacheOrGet(myAsyncPublishers, topic, publisher);
  }
  return publisher;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Nullable
private PsiDirectory findDirectoryImpl(@NotNull VirtualFile vFile) {
  PsiDirectory psiDir = myVFileToPsiDirMap.get(vFile);
  if (psiDir != null) return psiDir;

  if (Registry.is("ide.hide.excluded.files")) {
    if (myFileIndex.isExcludedFile(vFile)) return null;
  }
  else {
    if (myFileIndex.isUnderIgnored(vFile)) return null;
  }

  VirtualFile parent = vFile.getParent();
  if (parent != null) { //?
    findDirectoryImpl(parent);// need to cache parent directory - used for firing events
  }

  psiDir = PsiDirectoryFactory.getInstance(myManager.getProject()).createDirectory(vFile);
  return ConcurrencyUtil.cacheOrGet(myVFileToPsiDirMap, vFile, psiDir);
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
private InspectionTreeNode getToolParentNode(@NotNull String groupName, HighlightDisplayLevel errorLevel, boolean groupedBySeverity) {
  if (groupName.isEmpty()) {
    return getRelativeRootNode(groupedBySeverity, errorLevel);
  }
  ConcurrentMap<String, InspectionGroupNode> map = myGroups.get(errorLevel);
  if (map == null) {
    map = ConcurrencyUtil.cacheOrGet(myGroups, errorLevel, ContainerUtil.<String, InspectionGroupNode>newConcurrentMap());
  }
  InspectionGroupNode group;
  if (groupedBySeverity) {
    group = map.get(groupName);
  }
  else {
    group = null;
    for (Map<String, InspectionGroupNode> groupMap : myGroups.values()) {
      if ((group = groupMap.get(groupName)) != null) break;
    }
  }
  if (group == null) {
    group  = ConcurrencyUtil.cacheOrGet(map, groupName, new InspectionGroupNode(groupName));
    addChildNodeInEDT(getRelativeRootNode(groupedBySeverity, errorLevel), group);
  }
  return group;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
private InspectionTreeNode getRelativeRootNode(boolean isGroupedBySeverity, HighlightDisplayLevel level) {
  if (isGroupedBySeverity) {
    InspectionSeverityGroupNode severityGroupNode = mySeverityGroupNodes.get(level);
    if (severityGroupNode == null) {
      InspectionSeverityGroupNode newNode = new InspectionSeverityGroupNode(myProject, level);
      severityGroupNode = ConcurrencyUtil.cacheOrGet(mySeverityGroupNodes, level, newNode);
      if (severityGroupNode == newNode) {
        InspectionTreeNode root = myTree.getRoot();
        addChildNodeInEDT(root, severityGroupNode);
      }
    }
    return severityGroupNode;
  }
  return myTree.getRoot();
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
public ApplicationLevelNumberConnectionsGuardImpl() {
  myDelay = DELAY;
  mySet = new HashSet<CachingSvnRepositoryPool>();
  myService = Executors.newSingleThreadScheduledExecutor(ConcurrencyUtil.newNamedThreadFactory("SVN connection"));
  myLock = new Object();
  myDisposed = false;
  myRecheck = new Runnable() {
    @Override
    public void run() {
      HashSet<CachingSvnRepositoryPool> pools = new HashSet<CachingSvnRepositoryPool>();
      synchronized (myLock) {
        pools.addAll(mySet);
      }
      for (CachingSvnRepositoryPool pool : pools) {
        pool.check();
      }
    }
  };
  myCurrentlyActiveConnections = 0;
  myCurrentlyOpenedConnections = 0;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Nullable
public <T extends GroovyPsiElement> PsiType getType(@NotNull T element, @NotNull Function<T, PsiType> calculator) {
  PsiType type = myCalculatedTypes.get(element);
  if (type == null) {
    RecursionGuard.StackStamp stamp = ourGuard.markStack();
    type = calculator.fun(element);
    if (type == null) {
      type = UNKNOWN_TYPE;
    }
    if (stamp.mayCacheNow()) {
      type = ConcurrencyUtil.cacheOrGet(myCalculatedTypes, element, type);
    } else {
      final PsiType alreadyInferred = myCalculatedTypes.get(element);
      if (alreadyInferred != null) {
        type = alreadyInferred;
      }
    }
  }
  if (!type.isValid()) {
    error(element, type);
  }
  return UNKNOWN_TYPE == type ? null : type;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
private XDebugProcessStarter createDebugProcessStarter(@NotNull final TheRXProcessHandler processHandler,
                                                       @NotNull final ExecutionConsole executionConsole,
                                                       @NotNull final TheRDebugger debugger,
                                                       @NotNull final TheROutputReceiver outputReceiver,
                                                       @NotNull final TheRResolvingSession resolvingSession) {
  return new XDebugProcessStarter() {
    @NotNull
    @Override
    public XDebugProcess start(@NotNull final XDebugSession session) throws ExecutionException {
      return new TheRDebugProcess(
        session,
        processHandler,
        executionConsole,
        debugger,
        outputReceiver,
        resolvingSession,
        ConcurrencyUtil.newSingleThreadExecutor(EXECUTOR_NAME)
      );
    }
  };
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@Override
public PsiPackage findPackage(@NotNull String qualifiedName) {
  SoftReference<ConcurrentMap<String, PsiPackage>> ref = myPackageCache;
  ConcurrentMap<String, PsiPackage> cache = ref == null ? null : ref.get();
  if (cache == null) {
    myPackageCache = new SoftReference<ConcurrentMap<String, PsiPackage>>(cache = new ConcurrentHashMap<String, PsiPackage>());
  }

  PsiPackage aPackage = cache.get(qualifiedName);
  if (aPackage != null) {
    return aPackage;
  }

  for (PsiElementFinder finder : filteredFinders()) {
    aPackage = finder.findPackage(qualifiedName);
    if (aPackage != null) {
      return ConcurrencyUtil.cacheOrGet(cache, qualifiedName, aPackage);
    }
  }

  return null;
}
 

import com.intellij.util.ConcurrencyUtil; //导入依赖的package包/类
@NotNull
public static AttributesFlyweight create(Color foreground,
                                         Color background,
                                         @JdkConstants.FontStyle int fontType,
                                         Color effectColor,
                                         EffectType effectType,
                                         Color errorStripeColor) {
  FlyweightKey key = ourKey.get();
  if (key == null) {
    ourKey.set(key = new FlyweightKey());
  }
  key.foreground = foreground;
  key.background = background;
  key.fontType = fontType;
  key.effectColor = effectColor;
  key.effectType = effectType;
  key.errorStripeColor = errorStripeColor;

  AttributesFlyweight flyweight = entries.get(key);
  if (flyweight != null) {
    return flyweight;
  }

  return ConcurrencyUtil.cacheOrGet(entries, key.clone(), new AttributesFlyweight(foreground, background, fontType, effectColor, effectType, errorStripeColor));
}