RunnableExecutorPair list;
      synchronized (this) {
        if (executed) {
          return;
        }
        executed = true;
        list = runnables;
        runnables = null; // allow GC to free listeners even if this stays around for a while.
      }
      while (list != null) {
        executeListener(list.runnable, list.executor);
        list = list.next;
      }
    }

 *
 * <p>The extra bookkeeping done by cycle detecting locks comes at some cost to performance.
 * Benchmarks (as of December 2011) show that:
 *
 * <ul>
 *   <li>for an unnested {@code lock()} and {@code unlock()}, a cycle detecting lock takes 38ns as
 *       opposed to the 24ns taken by a plain lock.
 *   <li>for nested locking, the cost increases with the depth of the nesting:
 *       <ul>

                assertEquals(pageSize, list.size());
                assertEquals(allRecordCount, list.getAllRecordCount());
                assertEquals(100, list.getAllPageCount());
                assertEquals(20, list.getCurrentEndRecordNumber());
                assertEquals(2, list.getCurrentPageNumber());
                assertEquals(11, list.getCurrentStartRecordNumber());
                assertEquals(0, list.getOffset());

                final ListResultBean<WebConfig> list = new ListResultBean<>();
                list.add((WebConfig) crawlingConfigHelper.getCrawlingConfig("W1"));
                list.add((WebConfig) crawlingConfigHelper.getCrawlingConfig("W2"));
                list.add((WebConfig) crawlingConfigHelper.getCrawlingConfig("W3"));
                return list;
            }
        }, WebConfigBhv.class.getCanonicalName());

): List<R> {
    if (list.isEmpty()) {
        return noElementSplitFunction(expectedBucketNumber)
    }
    if (expectedBucketNumber == 1) {
        return listOf(smallElementAggregateFunction(list))
    }

    val roughSizeOfEachBucket = list.sumOf(toIntFunction) / expectedBucketNumber
    if (roughSizeOfEachBucket == 0) {

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<BadWord> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

    public int[] batchUpdate(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call,

    }

    public int[] batchInsert(List<BoostDocumentRule> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<BoostDocumentRule> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchInsert(list, call, null);
    }

    public int[] batchInsert(List<BoostDocumentRule> list, RequestOptionCall<BulkRequestBuilder> call,

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<DuplicateHost> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<JobLog> list) {
        return batchUpdate(list, null, null);
    }

    public int[] batchUpdate(List<JobLog> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchUpdate(list, call, null);
    }

    public int[] batchUpdate(List<JobLog> list, RequestOptionCall<BulkRequestBuilder> call,

  }

  public void testCartesianProduct_unrelatedTypes() {
    List<Integer> x = list(1, 2);
    List<String> y = list("3", "4");

    List<Object> exp1 = list((Object) 1, "3");
    List<Object> exp2 = list((Object) 1, "4");
    List<Object> exp3 = list((Object) 2, "3");
    List<Object> exp4 = list((Object) 2, "4");

    assertThat(Lists.<Object>cartesianProduct(x, y))