Peperangan loro yakozuna, utawa Cassandra vs HBase. Pengalaman tim Sberbank

Iki dudu guyon, misale jek gambar tartamtu iki paling akurat nggambarake inti saka database kasebut, lan ing pungkasan bakal jelas kenapa:

Miturut DB-Engines Ranking, rong database kolom NoSQL sing paling populer yaiku Cassandra (sabanjuré CS) lan HBase (HB).

Miturut karsane nasib, tim manajemen data loading ing Sberbank wis long ago lan kerjane rapet karo HB. Sajrone wektu iki, kita sinau kekiyatan lan kelemahane kanthi becik lan sinau carane masak. Nanging, anane alternatif ing wangun CS tansah meksa kita nyiksa awake dhewe kanthi mamang: apa kita nggawe pilihan sing bener? Menapa malih, asil bandingaken, dileksanakake dening DataStax, padha ngandika sing CS gampang ngalahaken HB karo meh skor crushing. Ing sisih liya, DataStax minangka pihak sing kasengsem, lan sampeyan ora kudu njupuk tembung kasebut. Kita uga bingung karo jumlah informasi sing rada cilik babagan kondisi tes, mula kita mutusake kanggo ngerteni dhewe sapa sing dadi raja BigData NoSql, lan asil sing dipikolehi dadi menarik banget.

Nanging, sadurunge nerusake menyang asil tes sing ditindakake, perlu kanggo njlèntrèhaké aspek penting saka konfigurasi lingkungan. Kasunyatane yaiku CS bisa digunakake ing mode sing ngidini mundhut data. Sing. Iki nalika mung siji server (simpul) tanggung jawab kanggo data saka tombol tartamtu, lan yen sakperangan alesan gagal, banjur Nilai tombol iki bakal ilang. Kanggo akeh tugas iki ora kritis, nanging kanggo sektor perbankan iki pangecualian tinimbang aturan. Ing kasus kita, penting kanggo duwe sawetara salinan data kanggo panyimpenan sing dipercaya.

Mulane, mung mode operasi CS ing mode replikasi telung dianggep, i.e. Nggawe casespace ditindakake kanthi parameter ing ngisor iki:

CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};

Sabanjure, ana rong cara kanggo njamin tingkat konsistensi sing dibutuhake. Aturan umum:
NW + NR > RF

Tegese jumlah konfirmasi saka simpul nalika nulis (NW) ditambah karo jumlah konfirmasi saka simpul nalika maca (NR) kudu luwih gedhe tinimbang faktor replikasi. Ing kasus kita, RF = 3, tegese pilihan ing ngisor iki cocog:
2 + 2 > 3
3 + 1 > 3

Amarga dhasar penting kanggo nyimpen data kanthi andal, skema 3 + 1 dipilih. Kajaba iku, HB nggarap prinsip sing padha, yaiku. perbandingan kuwi bakal luwih adil.

Sampeyan kudu nyatet sing DataStax nindakake ngelawan ing sinau, padha nyetel RF = 1 kanggo loro CS lan HB (kanggo terakhir kanthi ngganti setelan HDFS). Iki minangka aspek sing penting banget amarga pengaruhe ing kinerja CS ing kasus iki gedhe banget. Contone, gambar ing ngisor iki nuduhake paningkatan wektu sing dibutuhake kanggo mbukak data menyang CS:

Ing kene kita bisa ndeleng ing ngisor iki: luwih akeh benang saingan nulis data, luwih suwe. Iki pancen alami, nanging penting yen degradasi kinerja kanggo RF = 3 luwih dhuwur. Ing tembung liyane, yen kita nulis 4 Utas menyang 5 tabel saben (total 20), banjur RF = 3 ilang kira-kira 2 kaping (150 detik kanggo RF = 3 mungsuh 75 kanggo RF = 1). Nanging yen kita nambah beban kanthi ngemot data menyang 8 tabel kanthi 5 utas saben (40 total), banjur mundhut RF = 3 wis 2,7 kaping (375 detik lawan 138).

Mbok menawa iki minangka rahasia saka tes beban sing sukses sing ditindakake dening DataStax kanggo CS, amarga kanggo HB ing posisi kita ngganti faktor replikasi saka 2 dadi 3 ora ana pengaruhe. Sing. disk ora bottleneck HB kanggo konfigurasi kita. Nanging, ana akeh pitfalls liyane ing kene, amarga kudu dicathet yen versi HB kita rada ditambal lan diowahi, lingkungane beda banget, lsp. Iku uga worth kang lagi nyimak sing Mungkin aku mung ora ngerti carane nyiyapake CS bener lan ana sawetara cara sing luwih efektif kanggo bisa karo, lan Mugi kita bakal mangerteni ing komentar. Nanging dhisik dhisik.

Kabeh tes ditindakake ing kluster hardware sing dumadi saka 4 server, saben kanthi konfigurasi ing ngisor iki:

CPU: Xeon E5-2680 v4 @ 2.40GHz 64 utas.
Disk: 12 lembar SATA HDD
versi java: 1.8.0_111

Versi CS: 3.11.5

paramèter cassandra.ymlnomer_token: 256
hinted_handoff_enabled: bener
hinted_handoff_throttle_in_kb: 1024
maks_petunjuk_pangiriman_benang: 2
petunjuk_direktori: /data10/cassandra/pitunjuk
hints_flush_period_in_ms: 10000
max_hints_file_size_in_mb: 128
batchlog_replay_throttle_in_kb: 1024
authenticator: AllowAllAuthenticator
wewenang: AllowAllAuthorizer
role_manager: CassandraRoleManager
roles_validity_in_ms: 2000
permissions_validity_in_ms: 2000
credentials_validity_in_ms: 2000
partisi: org.apache.cassandra.dht.Murmur3Partitioner
data_file_direktori:
- /data1/cassandra/data # saben direktori dataN minangka disk sing kapisah
- /data2/cassandra/data
- /data3/cassandra/data
- /data4/cassandra/data
- /data5/cassandra/data
- /data6/cassandra/data
- /data7/cassandra/data
- /data8/cassandra/data
commitlog_directory: /data9/cassandra/commitlog
cdc_enabled: palsu
disk_failure_policy: mandheg
commit_failure_policy: mandheg
prepared_statements_cache_size_mb:
thrift_prepared_statements_cache_size_mb:
key_cache_size_in_mb:
key_cache_save_period: 14400
row_cache_size_in_mb: 0
row_cache_save_period: 0
counter_cache_size_in_mb:
counter_cache_save_period: 7200
saved_caches_directory: /data10/cassandra/saved_caches
commitlog_sync: periodik
commitlog_sync_period_in_ms: 10000
commitlog_segment_size_in_mb: 32
panyedhiya wiji:
- jeneng_kelas: org.apache.cassandra.locator.SimpleSeedProvider
paramèter:
- wiji: "*,*"
concurrent_reads: 256 # nyoba 64 - ora prabédan ngeweruhi
concurrent_writes: 256 # nyoba 64 - ora prabédan ngeweruhi
concurrent_counter_writes: 256 # nyoba 64 - ora prabédan ngeweruhi
concurrent_materialized_view_writes: 32
memtable_heap_space_in_mb: 2048 # nyoba 16 GB - luwih alon
memtable_allocation_type: heap_buffers
index_summary_capacity_in_mb:
index_summary_resize_interval_in_minutes: 60
trickle_fsync: palsu
trickle_fsync_interval_in_kb: 10240
panyimpenan_port: 7000
ssl_storage_port: 7001
ngrungokake_alamat: *
alamat_siaran: *
listen_on_broadcast_address: bener
internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start_native_transport: bener
native_transportation_port: 9042
start_rpc: bener
rpc_alamat: *
rpc_port: 9160
rpc_keepalive: bener
rpc_server_type: sinkronisasi
thrift_framed_transport_size_in_mb: 15
incremental_backups: palsu
snapshot_before_compaction: palsu
auto_snapshot: bener
kolom_indeks_ukuran_in_kb: 64
kolom_index_cache_size_in_kb: 2
concurrent_compactors: 4
compaction_throughput_mb_per_sec: 1600
sstable_preemptive_open_interval_in_mb: 50
maca_request_timeout_in_ms: 100000
range_request_timeout_in_ms: 200000
write_request_timeout_in_ms: 40000
counter_write_request_timeout_in_ms: 100000
cas_contention_timeout_in_ms: 20000
truncate_request_timeout_in_ms: 60000
request_timeout_in_ms: 200000
slow_query_log_timeout_in_ms: 500
cross_node_timeout: palsu
endpoint_snitch: GossipingPropertyFileSnitch
dynamic_snitch_update_interval_in_ms: 100
dynamic_snitch_reset_interval_in_ms: 600000
dynamic_snitch_badness_threshold: 0.1
request_scheduler: org.apache.cassandra.scheduler.NoScheduler
server_encryption_options:
internode_encryption: ora ana
opsi_enkripsi_klien:
diaktifake: palsu
internode_compression: dc
inter_dc_tcp_nodelay: palsu
tracetype_query_ttl: 86400
tracetype_repair_ttl: 604800
enable_user_defined_functions: palsu
enable_scripted_user_defined_functions: palsu
windows_timer_interval: 1
transparent_data_encryption_options:
diaktifake: palsu
tombstone_warn_threshold: 1000
tombstone_failure_threshold: 100000
batch_size_warn_threshold_in_kb: 200
batch_size_fail_threshold_in_kb: 250
unlogged_batch_across_partitions_warn_threshold: 10
compaction_large_partition_warning_threshold_mb: 100
gc_warn_threshold_in_ms: 1000
back_pressure_enabled: palsu
enable_materialized_views: bener
enable_sasi_indexes: bener

Setelan GC:

### Setelan CMS-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:SurvivorRatio=8
-XX:MaxTenuringThreshold=1
-XX:CMSInitiatingOccupancyFraction=75
-XX:+GunakakeCMSInitiatingOccupancyMung
-XX:CMSWaitDuration=10000
-XX:+CMSParallelInitialMarkEnabled
-XX:+CMSEdenChunksRecordAlways
-XX:+CMSClassUnloadingEnabled

Memori jvm.options diparengake 16Gb (kita uga nyoba 32 Gb, ora ana prabédan).

Tabel digawe kanthi prentah:

CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};

Versi HB: 1.2.0-cdh5.14.2 (ing kelas org.apache.hadoop.hbase.regionserver.HRegion kita ngilangi MetricsRegion sing nyebabake GC nalika jumlah wilayah luwih saka 1000 ing RegionServer)

Parameter HBase non-standarzookeeper.session.timeout: 120000
hbase.rpc.timeout: 2 menit
hbase.client.scanner.timeout.period: 2 menit
hbase.master.handler.count: 10
hbase.regionserver.lease.period, hbase.client.scanner.timeout.period: 2 menit
hbase.regionserver.handler.count: 160
hbase.regionserver.metahandler.count: 30
hbase.regionserver.logroll.period: 4 jam
hbase.regionserver.maxlogs: 200
hbase.hregion.memstore.flush.size: 1 GiB
hbase.hregion.memstore.block.multiplier: 6
hbase.hstore.compactionThreshold: 5
hbase.hstore.blockingStoreFiles: 200
hbase.hregion.majorcompaction: 1 dina
HBase Service Advanced Configuration Snippet (Safety Valve) kanggo hbase-site.xml:
hbase.regionserver.wal.codecorg.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec
hbase.master.namespace.init.timeout3600000
hbase.regionserver.optionalcacheflushinterval18000000
hbase.regionserver.thread.compaction.large12
hbase.regionserver.wal.enablecompressiontrue
hbase.hstore.compaction.max.size1073741824
hbase.server.compactchecker.interval.multiplier200
Pilihan Konfigurasi Java kanggo HBase RegionServer:
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSIinitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m
hbase.snapshot.master.timeoutMillis: 2 menit
hbase.snapshot.region.timeout: 2 menit
hbase.snapshot.master.timeout.millis: 2 menit
HBase REST Server Ukuran Log Maks: 100 MiB
HBase REST Server Serep File Log Maksimum: 5
HBase Thrift Server Ukuran Log Maks: 100 MiB
Serep File Log Maksimum HBase Thrift Server: 5
Ukuran Log Maks Master: 100 MiB
Master Serep File Log Maksimum: 5
RegionServer Max Log Ukuran: 100 MiB
Serep File Log Maksimum RegionServer: 5
Jendela Deteksi Master Aktif HBase: 4 menit
dfs.client.hedged.read.threadpool.size: 40
dfs.client.hedged.read.threshold.millis: 10 milidetik
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
Deskriptor File Proses Maksimum: 180000
hbase.thrift.minWorkerThreads: 200
hbase.master.executor.openregion.threads: 30
hbase.master.executor.closeregion.threads: 30
hbase.master.executor.serverops.threads: 60
hbase.regionserver.thread.compaction.small: 6
hbase.ipc.server.read.threadpool.size: 20
Utas Penggerak Wilayah: 6
Ukuran Heap Java Klien ing Byte: 1 GiB
HBase REST Server Default Group: 3 GiB
HBase Thrift Server Default Group: 3 GiB
Ukuran Heap Java saka Master HBase ing Byte: 16 GiB
Ukuran Heap Jawa saka HBase RegionServer ing Byte: 32 GiB

+Penjaga Kebun Binatang
maxClientCnxns: 601
maxSessionTimeout: 120000
Nggawe tabel:
hbase org.apache.hadoop.hbase.util.RegionSplitter ns:t1 UniformSplit -c 64 -f cf
ngowahi 'ns:t1', {NAME => 'cf', DATA_BLOCK_ENCODING => 'FAST_DIFF', COMPRESSION => 'GZ'}

Ana siji titik penting ing kene - katrangan DataStax ora nyatakake jumlah wilayah sing digunakake kanggo nggawe tabel HB, sanajan iki kritis kanggo volume gedhe. Mulane, kanggo tes, jumlah = 64 dipilih, sing ngidini nyimpen nganti 640 GB, i.e. meja ukuran medium.

Ing wektu tes, HBase duwe 22 ewu tabel lan 67 ewu wilayah (iki bakal mateni kanggo versi 1.2.0 yen ora kanggo tembelan kasebut ing ndhuwur).

Saiki kanggo kode. Amarga ora jelas konfigurasi sing luwih migunani kanggo database tartamtu, tes ditindakake ing macem-macem kombinasi. Sing. ing sawetara tes, 4 tabel dimuat bebarengan (kabeh 4 kelenjar digunakake kanggo sambungan). Ing tes liyane kita kerjo karo 8 tabel beda. Ing sawetara kasus, ukuran batch ana 100, ing liyane 200 (parameter kumpulan - deleng kode ing ngisor iki). Ukuran data kanggo nilai yaiku 10 bita utawa 100 bita (dataSize). Secara total, 5 yuta cathetan ditulis lan diwaca ing saben tabel saben wektu. Ing wektu sing padha, 5 utas ditulis/diwaca kanggo saben tabel (nomer utas - thNum), saben-saben nggunakake sawetara kunci dhewe (count = 1 yuta):

if (opType.equals("insert")) {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        StringBuilder sb = new StringBuilder("BEGIN BATCH ");
        for (int i = 0; i < batch; i++) {
            String value = RandomStringUtils.random(dataSize, true, true);
            sb.append("INSERT INTO ")
                    .append(tableName)
                    .append("(id, title) ")
                    .append("VALUES (")
                    .append(key)
                    .append(", '")
                    .append(value)
                    .append("');");
            key++;
        }
        sb.append("APPLY BATCH;");
        final String query = sb.toString();
        session.execute(query);
    }
} else {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        StringBuilder sb = new StringBuilder("SELECT * FROM ").append(tableName).append(" WHERE id IN (");
        for (int i = 0; i < batch; i++) {
            sb = sb.append(key);
            if (i+1 < batch)
                sb.append(",");
            key++;
        }
        sb = sb.append(");");
        final String query = sb.toString();
        ResultSet rs = session.execute(query);
    }
}

Dadi, fungsi sing padha diwenehake kanggo HB:

Configuration conf = getConf();
HTable table = new HTable(conf, keyspace + ":" + tableName);
table.setAutoFlush(false, false);
List<Get> lGet = new ArrayList<>();
List<Put> lPut = new ArrayList<>();
byte[] cf = Bytes.toBytes("cf");
byte[] qf = Bytes.toBytes("value");
if (opType.equals("insert")) {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        lPut.clear();
        for (int i = 0; i < batch; i++) {
            Put p = new Put(makeHbaseRowKey(key));
            String value = RandomStringUtils.random(dataSize, true, true);
            p.addColumn(cf, qf, value.getBytes());
            lPut.add(p);
            key++;
        }
        table.put(lPut);
        table.flushCommits();
    }
} else {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        lGet.clear();
        for (int i = 0; i < batch; i++) {
            Get g = new Get(makeHbaseRowKey(key));
            lGet.add(g);
            key++;
        }
        Result[] rs = table.get(lGet);
    }
}

Wiwit ing HB klien kudu ngurus distribusi seragam data, fungsi salting tombol katon kaya iki:

public static byte[] makeHbaseRowKey(long key) {
    byte[] nonSaltedRowKey = Bytes.toBytes(key);
    CRC32 crc32 = new CRC32();
    crc32.update(nonSaltedRowKey);
    long crc32Value = crc32.getValue();
    byte[] salt = Arrays.copyOfRange(Bytes.toBytes(crc32Value), 5, 7);
    return ArrayUtils.addAll(salt, nonSaltedRowKey);
}

Saiki sing paling menarik - asil:

Bab sing padha ing wangun grafik:

Kauntungan saka HB pancen nggumunake yen ana anggepan yen ana sawetara kemacetan ing persiyapan CS. Nanging, Googling lan nggoleki paramèter sing paling jelas (kaya concurrent_writes utawa memtable_heap_space_in_mb) ora nyepetake. Ing wektu sing padha, log sing resik lan ora sumpah apa-apa.

Data kasebut disebarake kanthi merata ing simpul, statistik saka kabeh simpul kira-kira padha.

Iki minangka statistik tabel saka salah sawijining simpulSpasi kunci: ks
Cacahe Waca: 9383707
Waca Latensi: 0.04287025042448576 ms
Jumlah Tulis: 15462012
Tulis Latensi: 0.1350068438699957 ms
Flushes sing ditundha: 0
Tabel: t1
Jumlah SST: 16
Spasi digunakake (urip): 148.59 MiB
Spasi digunakake (total): 148.59 MiB
Spasi sing digunakake dening jepretan (total): 0 bita
Memori tumpukan sing digunakake (total): 5.17 MiB
Rasio Kompresi SSTable: 0.5720989576459437
Jumlah partisi (kira-kira): 3970323
Jumlah sel sing bisa diowahi: 0
Ukuran data Memtable: 0 bita
Memtable saka memori tumpukan digunakake: 0 bita
Jumlah saklar Memtable: 5
Cacahe diwaca lokal: 2346045
Latensi maca lokal: NaN ms
Nomer nulis lokal: 3865503
Latensi nulis lokal: NaN ms
Siram sing ditundha: 0
Persen didandani: 0.0
Bloom Filter positif palsu: 25
Bloom Filter rasio palsu: 0.00000
Spasi panyaring Bloom digunakake: 4.57 MiB
Bloom Filter mati tumpukan memori digunakake: 4.57 MiB
Ringkesan indeks saka memori tumpukan digunakake: 590.02 KiB
Metadata kompresi saka memori tumpukan digunakake: 19.45 KiB
Partisi kompak minimal byte: 36
Partisi kompak bita maksimum: 42
Rata-rata partisi kompak: 42
Rata-rata sel urip saben irisan (limang menit pungkasan): NaN
Maksimum sel urip saben irisan (limang menit pungkasan): 0
Rata-rata nisan saben irisan (limang menit pungkasan): NaN
Watu nisan maksimal saben irisan (limang menit pungkasan): 0
Mutasi dropped: 0 byte

Nyoba kanggo nyuda ukuran batch (malah ngirim individu) ora ana efek, mung dadi luwih elek. Bisa uga nyatane iki pancen kinerja maksimal kanggo CS, amarga asil sing dipikolehi kanggo CS padha karo sing dipikolehi kanggo DataStax - kira-kira atusan ewu operasi per detik. Kajaba iku, yen kita ndeleng panggunaan sumber daya, kita bakal weruh manawa CS nggunakake CPU lan disk luwih akeh:

Tokoh nuduhake pemanfaatan sak roto kabeh tes ing baris kanggo loro database.

Babagan kauntungan maca kuat HB. Ing kene sampeyan bisa ndeleng manawa kanggo database loro, panggunaan disk sajrone maca arang banget (tes maca minangka bagean pungkasan saka siklus testing kanggo saben database, contone kanggo CS iki saka 15:20 kanggo 15:40). Ing kasus HB, alasane jelas - umume data macet ing memori, ing memstore, lan sawetara sing di-cache ing blockcache. Minangka kanggo CS, iku ora cetha banget cara kerjane, nanging daur ulang disk uga ora katon, nanging mung ing kasus, nyoba kanggo ngaktifake cache row_cache_size_in_mb = 2048 lan nyetel caching = {'keys': 'ALL', 'rows_per_partition': '2000000'}, nanging iki malah dadi luwih elek.

Sampeyan uga kudu disebutake maneh titik penting babagan jumlah wilayah ing HB. Ing kasus kita, nilai kasebut ditemtokake minangka 64. Yen sampeyan nyuda lan nggawe padha karo, contone, 4, banjur nalika maca, kacepetan mudhun 2 kaping. Alesane yaiku yen memstore bakal ngisi luwih cepet lan file bakal disiram luwih asring lan nalika maca, luwih akeh file sing kudu diproses, yaiku operasi sing rada rumit kanggo HB. Ing kahanan nyata, iki bisa diobati kanthi mikir liwat strategi presplitting lan compactification; utamane, kita nggunakake sarana sing ditulis dhewe sing nglumpukake sampah lan ngompres HFiles terus-terusan ing latar mburi. Sampeyan bisa uga kanggo tes DataStax mung nyedhiyakake 1 wilayah saben tabel (sing ora bener) lan iki bakal njlentrehake apa sebabe HB luwih murah tinimbang tes maca.

Kesimpulan awal ing ngisor iki dijupuk saka iki. Kanthi nganggep manawa ora ana kesalahan sing ditindakake sajrone tes, Cassandra katon kaya colossus kanthi sikil lempung. Luwih tepat, nalika dheweke ngimbangi siji sikil, kaya ing gambar ing wiwitan artikel, dheweke nuduhake asil sing relatif apik, nanging ing perang ing kondisi sing padha, dheweke kalah langsung. Ing wektu sing padha, kanthi nganggep panggunaan CPU sing sithik ing piranti keras, kita sinau kanggo nandur rong HBs RegionServer saben host lan kanthi mangkono nambah kinerja. Sing. Nganggep panggunaan sumber daya, kahanan kanggo CS malah luwih sumelang.

Mesthine, tes kasebut cukup sintetik lan jumlah data sing digunakake ing kene cukup sithik. Bisa uga yen kita ngalih menyang terabyte, kahanan bakal beda, nanging nalika kanggo HB kita bisa mbukak terabyte, kanggo CS iki dadi masalah. Asring mbuwang OperationTimedOutException sanajan volume kasebut, sanajan paramèter kanggo nunggu respon wis tambah kaping pirang-pirang dibandhingake karo standar.

Muga-muga kanthi upaya bebarengan kita bakal nemokake bottlenecks CS lan yen kita bisa nyepetake, banjur ing pungkasan kiriman aku mesthi bakal nambah informasi babagan asil pungkasan.

UPD : Nuwun sewu rencang-rencang, kula saged nyepetake waosan. yaiku:
159 ops (644 tabel, 4 stream, batch 5).
Ditambahake dening:
.withLoadBalancingPolicy(New TokenAwarePolicy(DCAwareRoundRobinPolicy.builder().build()))
Lan aku muter karo nomer thread. Asil kasebut ing ngisor iki:
4 tabel, 100 utas, kumpulan = 1 (potongan saben potongan): 301 ops
4 tabel, 100 utas, kumpulan = 10: 447 ops
4 tabel, 100 utas, kumpulan = 100: 625 ops

Mengko aku bakal aplikasi tips tuning liyane, mbukak siklus test lengkap lan nambah asil ing mburi kirim.

Source: www.habr.com