How to use

lockForWrite

method

in

org.apache.kylin.common.util.AutoReadWriteLock

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

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

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

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);
  }
}

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

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

  @Override
  public void onClearAll(Broadcaster broadcaster) throws IOException {
    try (AutoLock l = lock.lockForWrite()) {
      aclMap.clear();
    }
  }
}

public List<TableDesc> listAllTables(String prj) {
  try (AutoLock lock = srcTableMapLock.lockForWrite()) {
    return Lists.newArrayList(getAllTablesMap(prj).values());
  }
}

public void saveExternalFilter(ExternalFilterDesc desc) throws IOException {
  try (AutoLock lock = extFilterMapLock.lockForWrite()) {
    extFilterCrud.save(desc);
  }
}

public void removeExternalFilter(String name) throws IOException {
  try (AutoLock lock = extFilterMapLock.lockForWrite()) {
    extFilterCrud.delete(name);
  }
}

public void removeStreamingConfig(StreamingConfig streamingConfig) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.delete(streamingConfig);
  }
}

List<String> reloadAllTempStatement() throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.reloadAll();
    return new ArrayList<>(tmpStatMap.keySet());
  }
}

public CubeInstance reloadCubeQuietly(String cubeName) {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    CubeInstance cube = crud.reloadQuietly(cubeName);
    if (cube != null)
      Cuboid.clearCache(cube);
    return cube;
  }
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Broadcaster.Event event, String cacheKey)
      throws IOException {
    try (AutoReadWriteLock.AutoLock l = executableDigestMapLock.lockForWrite()) {
      if (event == Broadcaster.Event.DROP)
        executableDigestMap.removeLocal(cacheKey);
      else
        executableDigestCrud.reloadQuietly(cacheKey);
    }
  }
}

public void reloadSourceTableQuietly(String table, String project) {
  try (AutoLock lock = srcTableMapLock.lockForWrite()) {
    srcTableCrud.reloadQuietly(TableDesc.concatResourcePath(table, project));
  }
}

public ProjectInstance moveRealizationToProject(RealizationType type, String realizationName, String newProjectName,
    String owner) throws IOException {
  try (AutoLock lock = prjMapLock.lockForWrite()) {
    removeRealizationsFromProjects(type, realizationName);
    return addRealizationToProject(type, realizationName, newProjectName, owner);
  }
}

public CubeInstance updateCubeLookupSnapshot(CubeInstance cube, String lookupTableName, String newSnapshotResPath) throws IOException {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    cube = cube.latestCopyForWrite();
    CubeUpdate update = new CubeUpdate(cube);
    Map<String, String> map = Maps.newHashMap();
    map.put(lookupTableName, newSnapshotResPath);
    update.setUpdateTableSnapshotPath(map);
    return updateCube(update);
  }
}

public KafkaConfig updateKafkaConfig(KafkaConfig kafkaConfig) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    if (!kafkaMap.containsKey(kafkaConfig.resourceName()))
      throw new IllegalArgumentException("KafkaConfig '" + kafkaConfig.getName() + "' does not exist.");
    checkKafkaConfig(kafkaConfig);
    
    return crud.save(kafkaConfig);
  }
}

public DataModelDesc dropModel(DataModelDesc desc) throws IOException {
  try (AutoLock lock = modelMapLock.lockForWrite()) {
    crud.delete(desc);
    // delete model from project
    ProjectManager.getInstance(config).removeModelFromProjects(desc.getName());
    return desc;
  }
}

public void updateTempStatement(String sessionId, String statementId, String statement) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    TempStatementEntity entity = new TempStatementEntity(sessionId, statementId, statement);
    entity = prepareToOverwrite(entity, getTempStatEntity(sessionId, statementId));
    updateTempStatementWithRetry(entity, 0);
  }
}