How to use

AutoReadWriteLock

in

org.apache.kylin.common.util

public void removeKafkaConfig(KafkaConfig kafkaConfig) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.delete(kafkaConfig);
  }
}

public DataModelDesc getDataModelDesc(String name) {
  try (AutoLock lock = modelMapLock.lockForRead()) {
    return dataModelDescMap.get(name);
  }
}

@Nullable
private AclRecord getAclRecordByCache(String id) {
  try (AutoLock l = lock.lockForRead()) {
    if (aclMap.size() > 0) {
      return aclMap.get(id);
    }
  }
  try (AutoLock l = lock.lockForWrite()) {
    crud.reloadAll();
    return aclMap.get(id);
  } catch (IOException e) {
    throw new RuntimeException("Can not get ACL record from cache.", e);
  }
}

  @Test
  public void testBasics() {
    AutoReadWriteLock lock = new AutoReadWriteLock(new ReentrantReadWriteLock());
    try (AutoLock al = lock.lockForRead()) {
      Assert.assertTrue(lock.innerLock().getReadHoldCount() == 1);
    }
    Assert.assertTrue(lock.innerLock().getReadHoldCount() == 0);
    
    try (AutoLock al = lock.lockForWrite()) {
      Assert.assertTrue(lock.innerLock().getWriteHoldCount() == 1);
    }
    Assert.assertTrue(lock.innerLock().getWriteHoldCount() == 0);
  }
}

public CubeSegment refreshSegment(CubeInstance cube, TSRange tsRange, SegmentRange segRange) throws IOException {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    return segAssist.refreshSegment(cube, tsRange, segRange);
  }
}

public List<DataModelDesc> getModels() {
  try (AutoLock lock = modelMapLock.lockForRead()) {
    return new ArrayList<>(dataModelDescMap.values());
  }
}

public void promoteNewlyOptimizeSegments(CubeInstance cube, CubeSegment... optimizedSegments) throws IOException {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    segAssist.promoteNewlyOptimizeSegments(cube, optimizedSegments);
  }
}

public ManagedUser get(String name) {
  try (AutoReadWriteLock.AutoLock l = lock.lockForRead()) {
    return userMap.get(name);
  }
}

public void promoteCheckpointOptimizeSegments(CubeInstance cube, Map<Long, Long> recommendCuboids,
    CubeSegment... optimizedSegments) throws IOException {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    segAssist.promoteCheckpointOptimizeSegments(cube, recommendCuboids, optimizedSegments);
  }
}

public List<CubeDesc> listAllDesc() {
  try (AutoLock lock = descMapLock.lockForRead()) {
    return new ArrayList<CubeDesc>(cubeDescMap.values());
  }
}

public HybridInstance reloadHybridInstance(String name) {
  try (AutoLock l = lock.lockForWrite()) {
    return crud.reload(name);
  }
}

public ExternalFilterDesc getExtFilterDesc(String filterTableName) {
  try (AutoLock lock = extFilterMapLock.lockForRead()) {
    ExternalFilterDesc result = extFilterMap.get(filterTableName);
    return result;
  }
}

public void reloadAllHybridInstance() throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.reloadAll();
  }
}

public Collection<HybridInstance> listHybridInstances() {
  try (AutoLock l = lock.lockForRead()) {
    return hybridMap.values();
  }
}

public DataModelDesc reloadDataModel(String modelName) {
  try (AutoLock lock = modelMapLock.lockForWrite()) {
    return crud.reload(modelName);
  }
}

public List<KafkaConfig> listAllKafkaConfigs() {
  try (AutoLock l = lock.lockForRead()) {
    return new ArrayList(kafkaMap.values());
  }
}

public void delete(String username) {
  try (AutoReadWriteLock.AutoLock l = lock.lockForWrite()) {
    crud.delete(username.toUpperCase(Locale.ROOT));
  } catch (IOException e) {
    throw new RuntimeException("Can not delete user.", e);
  }
}

public List<ExternalFilterDesc> listAllExternalFilters() {
  try (AutoLock lock = extFilterMapLock.lockForRead()) {
    return Lists.newArrayList(extFilterMap.values());
  }
}

CubeInstance reloadCube(String cubeName) {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    return crud.reload(cubeName);
  }
}

public ProjectInstance getProject(String projectName) {
  // Null check is needed for ConcurrentMap does not supporting .get(null)
  if (projectName == null)
    return null;
  try (AutoLock lock = prjMapLock.lockForRead()) {
    return projectMap.get(projectName);
  }
}