Ieu sanés lulucon, sigana yén gambar tinangtu ieu paling akurat ngagambarkeun hakekat database ieu, sareng tungtungna bakal jelas naha:
Numutkeun kana DB-Engines Ranking, dua basis data kolom NoSQL anu pang populerna nyaéta Cassandra (saterusna CS) sareng HBase (HB).
Ku wasiat nasib, tim manajemén data loading kami di Sberbank parantos sarta gawéna raket jeung HB. Antukna, urang nalungtik kaunggulan jeung kalemahan na cukup alus sarta diajar kumaha carana masak eta. Nanging, ayana alternatif dina bentuk CS sok kapaksa urang nyiksa diri sakedik kalayan mamang: naha urang ngadamel pilihan anu leres? Leuwih ti éta, hasilna , Dilakonan ku DataStax, maranéhna ngomong yén CS gampang ngéléhkeun HB kalawan skor ampir crushing. Di sisi anu sanés, DataStax mangrupikeun pihak anu kabetot, sareng anjeun henteu kedah nyandak kecapna pikeun éta. Kami ogé bingung ku jumlah inpormasi anu rada alit ngeunaan kaayaan tés, janten kami mutuskeun pikeun terang sorangan saha raja BigData NoSql, sareng hasil anu dicandak tétéla pikaresepeun pisan.
Nanging, sateuacan ngaléngkah kana hasil tés anu dilakukeun, perlu ngajelaskeun aspék penting tina konfigurasi lingkungan. Kanyataanna nyaéta CS tiasa dianggo dina modeu anu ngamungkinkeun leungitna data. Jelema. Ieu nalika ngan hiji server (titik) jawab data tina hiji konci tangtu, sarta lamun keur sababaraha alesan gagal, nilai konci ieu bakal leungit. Pikeun loba tugas ieu teu kritis, tapi pikeun sektor perbankan ieu iwal tinimbang aturan. Dina kasus urang, hal anu penting pikeun mibanda sababaraha salinan data pikeun neundeun dipercaya.
Ku alatan éta, ngan mode operasi CS dina modeu réplikasi triple dianggap, i.e. Penciptaan casespace dilaksanakeun kalayan parameter ieu:
CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};
Salajengna, aya dua cara pikeun mastikeun tingkat konsistensi diperlukeun. Aturan umum:
NW + NR > RF
Anu hartosna jumlah konfirmasi tina titik nalika nyerat (NW) ditambah jumlah konfirmasi tina titik nalika maca (NR) kedah langkung ageung tibatan faktor réplikasi. Dina kasus urang, RF = 3, anu hartosna pilihan ieu cocog:
2 + 2 > 3
3 + 1 > 3
Kusabab éta fundamentally penting pikeun urang nyimpen data sakumaha reliably sabisa, skéma 3 + 1 dipilih. Sajaba ti éta, HB jalan dina prinsip sarupa, i.e. babandingan kitu bakal leuwih adil.
Ieu kudu dicatet yén DataStax tuh sabalikna dina ulikan maranéhanana, aranjeunna nyetél RF = 1 pikeun duanana CS jeung HB (pikeun dimungkinkeun ku ngarobah setelan HDFS). Ieu mangrupikeun aspék anu penting pisan sabab dampak kana kinerja CS dina hal ieu ageung. Contona, gambar di handap nembongkeun kanaékan waktu diperlukeun pikeun muka data kana CS:
Di dieu urang tingali di handap: beuki competing threads nulis data, beuki lila waktu nu diperlukeun. Ieu lumrah, tapi hal anu penting yén degradasi kinerja pikeun RF = 3 nyata luhur. Dina basa sejen, lamun urang nulis 4 threads kana 5 tabel unggal (total 20), lajeng RF = 3 leungit ku 2 kali (150 detik pikeun RF = 3 versus 75 pikeun RF = 1). Tapi lamun urang ningkatkeun beban ku loading data kana 8 tabel kalawan 5 threads unggal (total 40), leungitna RF = 3 geus 2,7 kali (375 detik versus 138).
Panginten ieu sabagean rusiah tina uji beban anu suksés dilakukeun ku DataStax pikeun CS, sabab pikeun HB di stand kami ngarobih faktor réplikasi tina 2 ka 3 henteu ngagaduhan pangaruh. Jelema. disk teu bottleneck HB pikeun konfigurasi urang. Sanajan kitu, aya loba pitfalls séjén di dieu, sabab kudu dicatet yén versi HB urang ieu rada patched na tweaked, lingkungan sagemblengna béda, jsb. Éta ogé sia noting yén meureun kuring ngan teu nyaho kumaha carana nyiapkeun CS leres tur aya sababaraha cara leuwih éféktif pikeun digawekeun ku eta, sarta kuring miharep kami bakal manggihan dina komentar. Tapi hal kahiji kahiji.
Sadaya tés dilaksanakeun dina kluster hardware anu diwangun ku 4 server, masing-masing kalayan konfigurasi ieu:
CPU: Xeon E5-2680 v4 @ 2.40GHz 64 benang.
Disk: 12 lembar SATA HDD
Vérsi java: 1.8.0_111
Vérsi CS: 3.11.5
parameter cassandra.ymljumlah_token: 256
hinted_handoff_enabled: leres
hinted_handoff_throttle_in_kb: 1024
max_hints_delivery_threads: 2
hints_directory: /data10/cassandra/pitunjuk
hints_flush_period_in_ms: 10000
max_hints_file_size_in_mb: 128
batchlog_replay_throttle_in_kb: 1024
authenticator: AllowAllAuthenticator
authorizer: AllowAllAuthorizer
role_manager: CassandraRoleManager
roles_validity_in_ms: 2000
permissions_validity_in_ms: 2000
credentials_validity_in_ms: 2000
partitioner: org.apache.cassandra.dht.Murmur3Partitioner
data_file_directories:
- /data1/cassandra/data # unggal diréktori dataN mangrupakeun disk misah
- /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: eureun
commit_failure_policy: eureun
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: périodik
commitlog_sync_period_in_ms: 10000
commitlog_segment_size_in_mb: 32
panyadia_bibit:
- class_name: org.apache.cassandra.locator.SimpleSeedProvider
parameter:
- siki: "*,*"
concurrent_reads: 256 # diusahakeun 64 - euweuh bédana noticed
concurrent_writes: 256 # diusahakeun 64 - euweuh bédana noticed
concurrent_counter_writes: 256 # diusahakeun 64 - euweuh bédana noticed
concurrent_materialized_view_writes: 32
memtable_heap_space_in_mb: 2048 # diusahakeun 16 GB - éta langkung laun
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
gudang_port: 7000
ssl_storage_port: 7001
ngadangukeun_alamat: *
alamat_siaran: *
listen_on_broadcast_address: leres
internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start_native_transport: leres
native_transport_port: 9042
start_rpc: leres
rpc_alamat: *
rpc_port: 9160
rpc_keepalive: leres
rpc_server_type: singkronisasi
thrift_framed_transport_size_in_mb: 15
Incremental_backups: palsu
snapshot_before_compaction: palsu
auto_snapshot: leres
kolom_index_size_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
read_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: euweuh
client_encryption_options:
diaktipkeun: 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:
diaktipkeun: palsu
tombstone_warn_threshold: 1000
tombstone_failure_threshold: 100000
bets_size_warn_threshold_in_kb: 200
bets_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: leres
enable_sasi_indexes: leres
Setélan GC:
### Setélan CMS-XX:+UseParNewGC
-XX: + UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:SurvivorRatio=8
-XX:MaxTenuringThreshold=1
-XX:CMSIinitiatingOccupancyFraction=75
-XX:+UseCMSIinitiatingOccupancyOnly
-XX:CMSWaitDuration=10000
-XX: + CMSParallelInitialMarkEnabled
-XX:+CMSEdenChunksRecordSalawasna
-XX:+CMSClassUnloadingEnabled
Memori jvm.options ieu disadiakeun 16Gb (urang ogé diusahakeun 32 Gb, euweuh bédana ieu noticed).
Tabél dijieun kalayan paréntah:
CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};Vérsi HB: 1.2.0-cdh5.14.2 (dina kelas org.apache.hadoop.hbase.regionserver.HRegion kami ngaluarkeun MetricsRegion anu nyababkeun GC nalika jumlah daérah langkung ti 1000 dina 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 dinten
HBase Service Advanced Configuration Snippet (Safety Valve) pikeun 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 pikeun 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 Max Log Ukuran: 100 MiB
HBase REST Server Cadangan File Log Maksimum: 5
HBase Thrift Server Max Log Ukuran: 100 MiB
HBase Thrift Server Cadangan File Log Maksimum: 5
Master Max Log Ukuran: 100 MiB
Master Cadangan File Log Maksimum: 5
RegionServer Max Log Ukuran: 100 MiB
RegionServer Nyadangkeun File Log Maksimum: 5
Jandéla Detéksi Master Aktif HBase: 4 menit (s)
dfs.client.hedged.read.threadpool.size: 40
dfs.client.hedged.read.threshold.millis: 10 milidetik (s)
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
Deskriptor File Prosés 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
Threads Pindah Daerah: 6
Ukuran tumpukan Java klien dina bait: 1 GiB
HBase REST Server Grup Default: 3 GiB
HBase Thrift Server Grup Default: 3 GiB
Ukuran Java Heap of HBase Master dina bait: 16 GiB
Ukuran Java Heap of HBase RegionServer dina Byte: 32 GiB
+Penjaga Kebon Binatang
maxClientCnxns: 601
maxSessionTimeout: 120000
Nyieun tabél:
hbase org.apache.hadoop.hbase.util.RegionSplitter ns:t1 UniformSplit -c 64 -f cf
ngarobah 'ns:t1', {NAME => 'cf', DATA_BLOCK_ENCODING => 'FAST_DIFF', COMPRESSION => 'GZ'}
Aya hiji titik penting di dieu - pedaran DataStax teu nyebutkeun sabaraha wewengkon dipaké pikeun nyieun tabel HB, sanajan ieu kritis pikeun volume badag. Ku alatan éta, pikeun tés, kuantitas = 64 dipilih, anu ngamungkinkeun nyimpen nepi ka 640 GB, i.e. méja ukuran sedeng.
Dina waktos tés, HBase ngagaduhan 22 rébu méja sareng 67 rébu daérah (ieu bakal maot pikeun versi 1.2.0 upami henteu pikeun patch anu disebatkeun di luhur).
Ayeuna keur kode. Kusabab teu jelas konfigurasi mana anu langkung nguntungkeun pikeun database tinangtu, tés dilaksanakeun dina sababaraha kombinasi. Jelema. dina sababaraha tés, 4 tabél dimuat sakaligus (sadayana 4 titik dipaké pikeun sambungan). Dina tés séjén kami digawé kalayan 8 tabel béda. Dina sababaraha kasus, ukuran bets éta 100, dina batur 200 (parameter bets - tingali kode handap). Ukuran data pikeun nilai nyaéta 10 bait atanapi 100 bait (dataSize). Dina total, 5 juta rékaman ditulis sareng dibaca dina unggal méja unggal waktos. Dina waktos anu sami, 5 utas ditulis/dibaca ka unggal tabel (nomer utas - thNum), anu masing-masing nganggo kisaran konci sorangan (count = 1 juta):
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);
}
}
Sasuai, fungsionalitas anu sami disayogikeun pikeun 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);
}
}
Kusabab dina HB klien kudu ngurus distribusi seragam data, fungsi salting konci kasampak kawas kieu:
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);
}
Ayeuna bagian paling narik - hasilna:
Hal anu sami dina bentuk grafik:
Kauntungannana HB jadi héran yén aya kacurigaan yén aya sababaraha jenis bottleneck dina setelan CS. Nanging, Googling sareng milarian parameter anu paling jelas (sapertos concurrent_writes atanapi memtable_heap_space_in_mb) henteu ngagancangkeun. Dina waktu nu sarua, log beresih jeung teu sumpah nanaon.
Data disebarkeun merata sakuliah titik, statistik ti sakabéh titik éta kira sarua.
Ieu naon statistik tabel kasampak kawas ti salah sahiji titikRuang konci: ks
Jumlah bacaan: 9383707
Baca Latensi: 0.04287025042448576 mdet
Jumlah Tulis: 15462012
Tulis Latensi: 0.1350068438699957 ms
Nungguhan Flushes: 0
Méja: t1
Jumlah SST: 16
Spasi dipaké (hirup): 148.59 MiB
Spasi dipaké (total): 148.59 MiB
Spasi dipaké ku snapshots (total): 0 bait
Pareum memori tumpukan dipaké (total): 5.17 MiB
Rasio Komprési SSTable: 0.5720989576459437
Jumlah partisi (perkiraan): 3970323
Jumlah sél métabel: 0
Ukuran data Memtable: 0 bait
Memtable kaluar memori numpuk dipaké: 0 bait
Jumlah switch Memtable: 5
Jumlah bacaan lokal: 2346045
Latensi bacaan lokal: NaN ms
Jumlah tulisan lokal: 3865503
Latensi nulis lokal: NaN ms
Siram ngantosan: 0
Persen perbaikan: 0.0
Bloom filter positip palsu: 25
Bloom filter ratio palsu: 0.00000
Mekar spasi filter dipaké: 4.57 MiB
Bloom filter kaluar tumpukan memori dipaké: 4.57 MiB
Kasimpulan indéks tina mémori tumpukan dipaké: 590.02 KiB
Métadata komprési tina mémori tumpukan dipaké: 19.45 KiB
Partisi Compacted bait minimum: 36
Partisi Compacted bait maksimum: 42
Partisi Compacted rata-rata bait: 42
Rata-rata sél hirup per nyiksikan (lima menit panungtungan): NaN
Maksimum sél hirup per irisan (lima menit panungtungan): 0
Rata-rata batu nisan per nyiksikan (lima menit panungtungan): NaN
Batu nisan maksimum per irisan (lima menit panungtungan): 0
Mutasi turun: 0 bait
Hiji usaha pikeun ngurangan ukuran bets (malah ngirim eta individual) teu boga pangaruh, eta ngan meunang parah. Ieu mungkin yen dina kanyataanana ieu bener kinerja maksimum pikeun CS, saprak hasil diala pikeun CS sarua jeung nu diala pikeun DataStax - ngeunaan ratusan rébu operasi per detik. Salaku tambahan, upami urang ningali pamakean sumber daya, urang bakal ningali yén CS nganggo langkung seueur CPU sareng disk:
Angka ieu nunjukkeun panggunaan nalika ngajalankeun sadaya tés sakaligus pikeun duanana pangkalan data.
Ngeunaan kaunggulan bacaan anu kuat HB. Di dieu anjeun bisa nempo yén pikeun duanana database, utilization disk salila maca pisan low (baca tés mangrupa bagian ahir siklus nguji pikeun tiap database, contona pikeun CS ieu ti 15:20 ka 15:40). Dina kasus HB, alesanna jelas - lolobana data ngagantung dina mémori, di memstore, sareng sababaraha anu disimpen dina blockcache. Sedengkeun pikeun CS, teu jelas pisan kumaha gawéna, tapi daur ulang disk ogé teu katingali, tapi ngan bisi, usaha ieu dilakukeun pikeun ngaktipkeun cache row_cache_size_in_mb = 2048 tur nyetel cache = {'konci': 'ALL', 'rows_per_partition': ' 2000000'}, tapi éta rada parah.
Éta ogé patut nyebut sakali deui titik penting ngeunaan jumlah wewengkon di HB. Dina hal urang, nilai ieu dieusian salaku 64. Lamun ngurangan eta sarta nyieun sarua jeung, contona, 4, lajeng nalika maca laju turun ku 2 kali. Alesanna nyaéta yén memstore bakal ngeusian langkung gancang sareng file bakal disiram langkung sering sareng nalika maca, langkung seueur file anu kedah diolah, anu mangrupikeun operasi anu rada rumit pikeun HB. Dina kaayaan nyata, ieu bisa diolah ku pamikiran ngaliwatan strategi presplitting na compactification; hususna, urang ngagunakeun utiliti ditulis sorangan nu ngumpulkeun sampah jeung compresses HFiles terus-terusan di tukang. Ieu rada mungkin yen pikeun tés DataStax aranjeunna alokasi ngan 1 wewengkon per tabel (nu teu bener) jeung ieu rada bakal netelakeun naha HB éta jadi inferior dina tés bacaan maranéhanana.
Kacindekan awal di handap ieu ditarik tina ieu. Anggap teu aya kasalahan utama anu dilakukeun nalika tés, teras Cassandra katingalina sapertos kolosus kalayan suku liat. Leuwih tepat, bari saimbang dina hiji leg, sakumaha dina gambar di awal artikel, némbongkeun hasil rélatif alus, tapi dina gelut dina kaayaan anu sarua manehna leungit outright. Dina waktos anu sami, kalayan ngitung pamakean CPU anu rendah dina parangkat keras urang, urang diajar melak dua RegionServer HBs per host sahingga ngagandakeun kinerja. Jelema. Nyandak kana akun pamanfaatan sumber daya, kaayaan pikeun CS bahkan langkung parah.
Tangtosna, tés ieu rada sintétis sareng jumlah data anu dianggo di dieu kawilang sederhana. Ieu mungkin yen lamun urang switched ka terabytes, kaayaan bakal béda, tapi bari pikeun HB urang tiasa ngamuat terabytes, pikeun CS ieu tétéla jadi masalah. Éta sering ngalungkeun OperationTimedOutException sanaos jilid ieu, sanaos parameter ngantosan réspon parantos ningkat sababaraha kali dibandingkeun sareng standar.
Kuring miharep yén ngaliwatan usaha babarengan urang bakal manggihan bottlenecks of CS sarta lamun urang bisa nyepetkeun eta up, lajeng dina tungtung pos kuring pasti bakal nambahan informasi ngeunaan hasil ahir.
UPD: Hatur nuhun kana saran ti babaturan, kuring junun ngagancangkeun bacaan. Éta:
159 ops (644 méja, 4 aliran, bets 5).
Ditambahkeun:
.withLoadBalancingPolicy(TokenAwarePolicy anyar(DCAwareRoundRobinPolicy.builder().build()))
Sareng kuring maén sareng jumlah benang. Hasilna nyaéta kieu:
4 méja, 100 utas, bets = 1 (sapotong demi sapotong): 301 ops
4 méja, 100 utas, bets = 10: 447 ops
4 méja, 100 utas, bets = 100: 625 ops
Engké kuring bakal nerapkeun tips tuning séjén, ngajalankeun siklus nguji pinuh sarta nambahan hasil dina tungtung pos.
sumber: www.habr.com