public List<RegionTask> splitRangeByRegion(List<KeyRange> keyRanges, TiStoreType storeType) {
    if (keyRanges == null || keyRanges.size() == 0) {
      return ImmutableList.of();
    }

    ...

    while (true) {
      ...
      while (regionStorePair == null) {
        try {
          regionStorePair = regionManager.getRegionStorePairByKey(range.getStart(), storeType, bo);

          if (regionStorePair == null) {
           // throw exception
           ...
          }
        } catch (Exception e) {
		   ...
        }
      }

      TiRegion region = regionStorePair.first;
      idToRegion.putIfAbsent(region.getId(), regionStorePair);

	  // update range start, if range start is bigger or equal the range end,
      // use next range of list.
      ...
 }
public Pair<TiRegion, Store> getRegionStorePairByKey(
      ByteString key, TiStoreType storeType, BackOffer backOffer) {
    TiRegion region = cache.getRegionByKey(key, backOffer);
    // get store from region.
    ...
    return Pair.create(region, store);
}

public synchronized TiRegion getRegionByKey(ByteString key, BackOffer backOffer) {
      TiRegion region = regionCache.get(getEncodedKey(key));
	  ...

      if (region == null) {
        ...
        // only get one region here.
        region = pdClient.getRegionByKey(backOffer, key);
        if (!putRegion(region)) {
          throw new TiClientInternalException("Invalid Region: " + region.toString());
        }
      }

      return region;
  }

   public List<RegionTask> splitRangeByRegion(List<KeyRange> keyRanges, TiStoreType storeType) {
    // init some data.
    ...
    for (KeyRange range : keyRanges) {
      while (true) {
        try {
          List<RegionStorePair> regionStorePairList =
              regionManager.getAllRegionStorePairsInRange(range, storeType, bo);
          // add data to result.
		  ...
          break;
        } catch (Exception e) {
 		  ...
          bo.doBackOff(BackOffFuncType.BoRegionMiss, e);
        }
      }
    }
    // build result
	...
    return resultBuilder.build();
  }  

public List<RegionStorePair> getAllRegionStorePairsInRange(
      KeyRange range, TiStoreType storeType, BackOffer backOffer) {
    // init some data.
	...
    while (toRawKey(startKey).compareTo(toRawKey(endKey)) < 0) {
      try {
        ...
        ArrayList<TiRegion> regions =
            cache.getRegionsInRangeWithLimit(range, backOffer, REGION_SCAN_LIMIT);
        // construct region and store pair
		...
        startKey = regions.get(regions.size() - 1).getEndKey();
        range = KeyRange.newBuilder().setStart(startKey).setEnd(endKey).build();
      } catch (Exception e) {
   		...
      }
    }
    return allRegionStorePairs;
  }

public synchronized ArrayList<TiRegion> getRegionsInRangeWithLimit(
        KeyRange range, BackOffer backOffer, int scanLimit) {
      // init some data.
      ...
      while (toRawKey(startKey).compareTo(toRawKey(endKey)) < 0
          && regionsInRange.size() < scanLimit) {
        TiRegion region = regionCache.get(getEncodedKey(startKey));
        while (region == null) {
          try {
            updateCacheInRangeWithLimit(startKey, endKey, scanLimit, backOffer);
            region = regionCache.get(getEncodedKey(startKey));
            ...
          } catch (Exception e) {
            ...
          }
        }
        ...
        startKey = region.getEndKey();
      }
      return regionsInRange;
    }

private synchronized void updateCacheInRangeWithLimit(
        ByteString startKey, ByteString endKey, int limit, BackOffer backOffer)
        throws GrpcException {
        // get muti region from pd.
   List<TiRegion> regions = pdClient.scanRegionWithLimit(backOffer, startKey, endKey, limit);
   for (TiRegion region : regions) {
      // Region without leader.
      if (region.getLeader() == null || region.getLeader().getId() == 0) {
        continue;
      }
      // Region which has leader will be inserted into cache.
      if (!putRegion(region)) {
        throw new TiClientInternalException("Invalid Region: " + region);
      }
 }