quindi non so voi ma è così
è piuttosto raro che io abbia l’opportunità
pieno di un pisolino come molto raro che nessuno
di noi arrivare a fare questo forse gli piace
piccole cose ma nessuno dei nostri grandi sistemi
forse pensi che sia così forse
è così che pensi che la tua app appaia ma
probabilmente la maggior parte di voi è la vostra app di più
così è davvero molto
sofisticato è molto potente
facendo un sacco di cose bene è in esecuzione
affari nel mio caso abbiamo sistemi
costruito e gestito un miliardo di dollari
business a livello globale e questa è una foto
di New York
okay, New York è stata costruita sopra
decenni e l’infrastruttura di esso
serve uno scopo ma come noi come è cresciuto
intorno ad esso una città importante come questa
ha la sfida di come iniziamo
modernizzare alcuni aspetti di esso in un
modo economicamente vantaggioso senza strappi
la città perché non è solo la realtà
ora se la tua app è come quella che puoi
alzati e lascia che non hai bisogno di me
mai effettivamente visto un’app come questa se
hai visto quei fumetti di simili
un ingegnere e architetti che conosce
questa volta ho intenzione di farlo bene e
hanno questa visione e poi piace
sei pannelli dopo è tutto ciò che abbiamo fatto
ancora una volta il mio obiettivo è quello di prendere forse
alcuni degli aspetti di questo e portare
torna a New York City okay
così pochi anni fa abbiamo avuto un risultato molto semplice
Caso d’uso che stavamo cercando di raggiungere
volevamo avere una sola chiamata di rete
vieni dai nostri dispositivi e poi
sfruttare la rete a bassa latenza del nostro
infrastruttura lato server e
concorrenza che era disponibile a noi su
i nostri potenti server al contrario di
lasciando piccoli dispositivi mobili o economici
come scatole da $ 30 e perché Netflix
distribuisce a tutto ciò che attacca un
schermo e quindi abbiamo tutto
giù a come il 20 e 30 dollari
silicio e fino al multi
cento o più migliaia di
dollari di attrezzature che abbiamo
tutto in mezzo e il più economico
dispositivi che non riescono a gestire tutti
la concomitante composizione di tutto il
servizi web quindi volevamo spingere tutti
quel lato server così lungo il nostro cammino
capito che per farlo efficacemente noi
voluto essere in grado di abbracciare un noi asincrona
necessario per farlo nel modo più naturale
in modo ovvio
facciamolo chiamata spalle chiamano spalle
efficacemente è ciò che tutto bolle
giù
– ad un certo punto ne metti un sacco
ostruzioni in cima ma a un certo punto
il lavoro finisce e ti dice quando
è fatto e si richiama in
realtà dei casi d’uso che stavamo provando
risolvere per con composizione di servizio così
vogliamo comporre più servizi
insieme senza rinunciare all’errore
gestione e produttività degli sviluppatori e
in realtà molte soluzioni che vanno
lungo il percorso asincrono finiscono per sacrificare a
molto in queste due aree e quindi c’era
abbastanza di noi nella squadra che aveva
sperimentato quel dolore che non abbiamo fatto
solo in fretta, percorro questa strada che ero
abbastanza fortunato che ho avuto un sacco di
diversi ingegneri intorno a me da
sfondi diversi e uno di loro
era Jeff er Hussain da cui proveniva
Microsoft che ha trascorso un paio di mesi
litigare con me per picchiarmi fino a quando
Ho ammesso che aveva ragione ed è così
come sono stato introdotto nel reattivo
spazio di programmazione quindi abbiamo scelto di adottare
asincrono ma per farlo senza chiamata raw
spalle così se guardo Java così com’è
la maggior parte di Netflix è in esecuzione sulla JVM
e la maggior parte di questo è ancora solo giocando
Java e sempre di più è Java 8
per fortuna il futuro e il futuro della lista
di tè con quelle due cose che potremmo
in realtà indirizzano molti dei nostri casi d’uso
ma onestamente quella lista di T in un futuro
non è esattamente giusto perché siamo ancora
devo aspettare per l’intera cosa
completa prima che ritorni e anche a
il tempo in cui abbiamo iniziato questo percorso
Futures Java hanno appena visto che tu
in realtà non li puoi comporre tu finisci
bloccando le discussioni su di loro non lo farò
approfondisci oggi le liste
sono in realtà qualcosa abbiamo a che fare con questo
è l’esempio stereotipato di un elenco di
liste di film e questo è per fare
come la griglia sulla home page e così abbiamo
scorrere l’elenco delle liste e quindi
al suo interno iteriamo su tutto il
film all’interno di un elenco e quindi all’interno
che andiamo a prendere un sacco di roba
e così se fate questo ingenuamente si finisce
con due cose
centinaia di chiamate di rete e anche tu
finire con una funzione di passaggio come a
cascata che continua ad andare avanti
per sempre e così è stato esattamente noi
non volevo
è successo c’è anche questo caso
che non avresti mai fatto con a
normale futuro questo futuro elencare il
futuro del tè ma semanticamente è così
in realtà ciò che volevamo, vogliamo calciare
fuori da questo lavoro in modo asincrono che sarebbe
essere in grado di rimandare a noi singoli
oggetti lungo la pipa come sono venuti ed essere
in grado di lavorare su di loro come sono arrivati
quindi lo sapevamo già semanticamente
questo è quello che volevamo fare proprio questo
non era giusto e siamo finiti lì
modi diversi di gestire questo ma noi
finito per adottare l’osservabile RX
scrivi in modo che la nostra X sia sinonimo di reattivo
estensioni nel nostro prescrizione che
potrebbe essere una prescrizione per Java non lo faccio
sappi ma questo le estensioni reattive
per Java ci ha dato questo tipo osservabile
e abbiamo finito per trattare tutto come un
in streaming quindi solo tutti i dati che arrivano in questo
è solo un flusso di dati, che sia
un oggetto molti oggetti o un infinito
flusso di dati che abbiamo appena iniziato a trattare
tutto come un flusso quindi cosa è cosa
la nostra API sembrava al momento
tutto ciò stava bloccando le chiamate API come
che ora non ci occupiamo molto
ordina prodotti e lo stato della spedizione ma
Ho deciso di usare qualcosa di diverso da
rispetto agli ismi Netflix che io
in genere uso e in questo caso si recupera
tutti gli ordini e poi per ogni ordine
vai a prendere tutti i prodotti e per ciascuno
prodotto si preleva la spedizione
stato così quando vado al mio amazon.com
pagina Vedo cose simili come questa okay
questo è molto comune come praticamente tutti
sito di commercio che ho mai usato ha un po ‘
pagina che viene renderizzata dietro il
scene che posso immaginare questo flusso
succede e l’API è sotto di esso
che stiamo usando questi sono tipici
l’ API di blocco è che siamo stati tutti
usando per sempre bene, il problema è questo
se lo metti insieme in modo ingenuo
si finisce con l’attraversamento di questo
uno stile cascata in ogni spedizione
chiamate di stato diciamo 100 millisecondi
Ho capito qui così puoi solo visualizzare
e tu lo attraversi e c’è
assolutamente nessuna concorrenza in corso
qualsiasi
ora sto bene con Java
Concorrenza in pratica prenota quel treno
il libro è seduto sulla mia scrivania è uno di
solo due libri ho ancora in carta
forma ed è un ottimo libro ma onestamente
la maggior parte di noi non dovrebbe dover leggere
e anche se ho letto quella cosa
due volte e ancora mi riferisco ad esso ancora
rovinare tutto e
avevamo dozzine di ingegneri e anche noi
un ingegnere dell’interfaccia utente ha fatto un passo
in queste basi di codice e abbiamo appena saputo
che possiamo avere semafori nel nuovo
Texas e mi piace come lanciare discussioni
a caso e tutto quel genere di cose e
aspettandoci che funzioni l’ambiente
stavano lavorando con in questo è ciò che il nostro
pila trattata con tutti i nostri inter
la comunicazione di processo era prevalentemente
fatto con Apache HCP che abbiamo
memcache D ed ecco la cosa triste è
anche se il suo cliente è in realtà
l’esecuzione su un ciclo di eventi ha avuto un blocco
L’API oltre a questo non espone effettivamente il
asincronia BIA al di sotto e così
sei ancora seduto e stai bloccando su un
la chiamata asincrona ha bloccato Cassandra
in Tomcat e servlet come quello è il
mondo in cui eravamo e gran parte dei nostri
la roba continua a bloccarsi e quindi via
la terra ho introdotto un modello reattivo
in una pila come quella e così il
la realtà era che possiamo andare a correre
ricostruire tutto specialmente per
qualcosa che era ingegneri non provati
non stavano ancora comprando l’ idea ma
potremmo cambiare il nostro livello di servizio e così via
c’era uno strato all’interno di questa pila
siamo stati in grado di entrare e di cambiare noi
aveva piena libertà di farlo era
isolato al solo la nostra squadra e abbiamo potuto
iterate su di esso e così abbiamo creato questo
facciata asincrona e abbiamo bloccato proprio dentro
tra le parti che non potevamo
il controllo in alto è il servlet e
Infrastruttura Tomcat che non eravamo
sta per cambiare è che è un intero
cosa diversa ne parlerò
più alla fine della presentazione e
sotto tutto il codice che esegue tutto
la logica aziendale e tutto l’IPC e
tutte quelle cose che non potremmo in nessuna
Il tempo passa presto , quindi quello che abbiamo fatto è stato noi
è passato da un blocco del modello di blocco
API a aspi asincrona che noi
è finito per chiamare api osservabili
perché finiscono tutti per assomigliare
che invece di digitare T è un
osservabile di T e così tutto il nostro intero
livello di servizio è stato commutato a questo
modello in cui tutto il metodo chiama
restituito e osservabile di qualcosa e
ciò che permette questo è molto banale
esempio ma solo per mostrare che il
stato di spedizione ora che era
in modo sincrono invocandolo ancora
lo stesso aspetto di nidificazione così
la semantica è ancora lì, io ancora
vedilo a due livelli come me
non era prima ma ora è seduto
all’interno di un flusso osservabile asincrono che
è all’interno di un altro osservabile asincrono
flusso e il modo in cui questo si comporta ora
quando premo il gioco su questo funziona e poi
tutto scorre dentro perché quello che fa è
facendo in modo che sia tutto asincrono
mi permette di dichiarare quello che voglio io
da fare e quindi il runtime può scegliere
la concorrenza che sta andando a
eseguire a così posso iniziare
sfruttare la concorrenza
capacità della mia macchina e I / O
con cui sto interagendo in modo che il
l’effettiva latenza dell’esperienza utente ora può
essere migliorato in modo significativo, ecco tutto
cose di cui tutti sappiamo bene questo
inizia a darmi gli strumenti per ottenere
Ecco, quindi, come posso davvero ottenere da quello
ottenere il metodo di stato di spedizione che è
bloccando a uno che è asincrono così Rx è un
strumento che usiamo per fare questo tipo di
roba così un modo molto semplice siamo noi
letteralmente avvolgere solo le chiamate di blocco
e quindi c’è un meccanismo in rx an
l’operatore ha chiamato rimandare che siamo
letteralmente dicendo rinviare l’esecuzione di questo
fino a quando non torno più tardi
dichiarare il lavoro da fare quando si è
eseguire eseguire questo blocco di codice che è
seduto qui in una lambda e poi quando
tu corri questo è questo è un
parte importante quando in realtà sono
sottoscritto per iscriversi su questo
scheduler in questo caso lo metti su
un schedulatore di I / O che sta per mettere
su fili che sono là fuori
destinato a essere bloccato con il blocco il
okay quindi non c’è magia qui
stiamo solo aggiungendo discussioni attraverso il nostro
sistema come qualcuno di voi sta per sussultare
e piango e ne parlerò più che più tardi sì
abbiamo centinaia di centinaia di thread
in alcuni dei nostri sistemi ed è triste
triste stato di cose, ma è meglio per
il caso d’uso che avevamo dove è
quasi tutti i / o che erano seduti quando
esegue ciò che invoca quindi ottenere
stato di spedizione in modo bloccante e
blocca che i / o thread e poi quando
alla fine ritorna dice basta prendere
quel valore di T e restituirlo come un
osservabile
quindi cosa succede se ho una lista di ordini I
in realtà non voglio avere questo turno
in un elenco di ordine osservabile perché
che siamo in grado di sconfiggere il punto di quello che ho
stava cercando di raggiungere e così quello
lista di ordine può diventare osservabile di
Ordina così quando ti iscrivo a questo
emette ogni elemento della lista a me
ora non ne sto conseguendo davvero
in streaming ma questo mi sta solo facendo
in un modello di programmazione asincrono la via
che puoi farlo è esattamente lo stesso
l’unica differenza qui è che ho rimandato
iscriviti e ricevi gli ordini che uso
da invece di solo e da solo
converte un iterabile in osservabile
niente di tutto ciò che speciale qui così a
livello base ci siamo letteralmente imbattuti
il nostro sistema di avvolgimento tutto
discussioni e siamo stati in grado di solo con
questa capacità migliora la latenza dell’utente
ma in un modo che potremmo effettivamente
ancora motivo perché lo strumento ha dato
noi la capacità di comporlo andiamo a
un po ‘più lontano se lo sono davvero
lavorando a JDBC che immagino almeno
alcuni di voi hanno ancora a che fare con esso
per fortuna non ho avuto a che fare con
JDBC in quattro anni sono molto felice
che il JDBC è ancora il vero
l’ unico modo legittimo per accedere a
un sacco di database e quindi se il tuo codice
in realtà sta interagendo con JDBC
può iniziare a fare cose diverse così
nel blocco che puoi effettivamente vedere
che si accumulano tutti i dati in un
struttura dei dati come sta tornando così
lo stiamo ritirando dal database
e mentre sta tornando abbiamo accumulato
e questo significa che stavano assegnando
memoria e stiamo anche tenendo l’utente
fino a quando non abbiamo finito di tirare
tutto giù metterlo in un data
struttura diamo loro i dati
struttura li iterano sopra di nuovo e
allora devono buttarlo via e
se tu raccogliessi i rifiuti
passare al modello di flusso osservabile
metti lo stesso codice all’interno di create e
mentre stai ricevendo le risposte
in realtà sei solo sulla prossima cosa a loro
fuori il flusso mentre li ricevi
e così abbiamo completamente eliminato il
bisogno di quel livello aggiuntivo di oggetto
l’allocazione e il buffering solo questo è un
grande gioco perché ora sto solo lasciando
i dati fluiscono attraverso e io posso
reagire ad esso mentre viene trasmesso il
conduttura
piuttosto che buffering in passaggi
lungo il modo in cui il terminale indica
completamento riuscito ed errato
ci sono e questo sta mostrando il ponte
tra un blocco e non blocco
mondo perché JDBC lo sta bloccando
getterò delle eccezioni e devo farlo
li cattura
supporta anche unsubscribed perché in
il mio banale esempio qui ho deciso di
selezionare la stella dalla tabella enterica e
quindi probabilmente non voglio
tira giù l’ intero tavolo e così questo
mi consentirà di annullare l’iscrizione
con grazia e si chiuderà il tutto
in modo che se voglio solo prendere cinque
i valori si risolveranno da soli
pulire e pulire tutte le risorse
invece di succhiare l’intero database
giù e buttando tutto via
e ovviamente perché JBC sta bloccando I
devo metterlo su un programmatore di I / O
ora ti mostrerò di più
esempio complicato e voglio fare
questo in modo che tu possa vedere il potere
come tu che sei lì e questo reattivo
tirare indietro la pressione di stile si è evoluta
di collaborazione nel settore con
come tipo sicuro e fondamentale e Twitter
e altri e ha portato al
specifica dei flussi reattivi che
appena andato 100 di recente e il grande
La cosa su questo è che stiamo ottenendo
la stessa semantica per come fare
streaming con contropressione su molti
diverse società e biblioteche quindi Rx
java è stato coinvolto in questo diritto
fin dall’inizio e quindi sosteniamo la
la semantica e così in java per quelli
di voi che avete la fortuna di lavorare
c-sharp e altre lingue con
async / await
è solo schermare i tuoi occhi che dobbiamo fare
tutto a mano quindi dobbiamo mettere uno stato
macchina in atto per fare questo
async / attendi roba di stile e così vado
per mostrarti un codice che è come il
nel mezzo non ho intenzione di mostrarti il
macchina di stato reale ma sto andando a
mostraci i pezzi di noi e noi siamo
andando a creare un osservabile in questo
particolare astrazione che usiamo solo per
guidare la macchina di stato per noi il
lo stato attuale al suo interno è il set di risultati
che torneremo dal
jvc okay
quando questa macchina a stati inizia il primo
cosa fa è uno stato costruito e
così vedrai che all’interno di esso si ottiene la
connessione al database creiamo il
affermazione corretta
configurazione quindi questa configurazione è
fondamentalmente lo fai in JBC per dirlo a
non tamponare tutto per te così anni
fa quando stavo lavorando con il mio sequel a
è sempre divertente quando sei finito
come gonfiore vostro vostro spazio di memoria a
come 10 concerti perché hai provato a caricare
l’ intero database in questo dice il
Driver JDBC su se il database supporta
per trasmettere i dati a te invece di
tirando giù tutto in buffering
memoria e poi dandolo a te quale
è quando stai trasmettendo grandi quantità
dei dati che vuoi fare questo
specialmente quando stai facendo qualcosa
così che quindi lo stato viene creato
quello che fa è che in realtà ha un
negoziazione bidirezionale tra il
consumatore e il produttore e quando il
il consumatore esprime la capacità di ricevere
dati che richiede i dati alla macchina di stato
invocherà poi questo lambda come molti
volte in quanto ha bisogno di soddisfare questo e così
quando entra in quello recupera il
stato e poi dice se il set di risultati
ha dati e questa è una chiamata bloccante
perché è JDBC quindi emette il prossimo
altrimenti tutto si completa se non c’è
ulteriori dati perché JDBC lo sta bloccando
genererà un’eccezione quindi questo è il
ponte tra il blocco e il non
bloccare i mondi e poi catturerei
che ed emettono l’errore e poi il
importante quando quando lo stato
la macchina si spegne e mi dà
l’ opportunità di terminare e pulire
tutto e quello succede se
è un successo terminante
termine un errore o se ho
annullato l’abbonamento a una risorsa da chiudere
prematuramente passerà sempre
il passaggio di pulizia quindi condivido questo perché
questo è importante per lo streaming di sincronizzazione
sistemi che se non hai questo tipo
di una macchina statale dietro le quinte di te
finisci con il buffer gonfiare o uscire
perdita di dati di memoria cose diverse come
che la pressione posteriore è importante in un
sincronizzare i sistemi nello stesso modo in cui è
sincrono è solo un po ‘più complicato
per avere ragione in un sistema asincrono e così via
questo è un meccanismo per affrontare
quello e certamente perché siamo
colmare tra sincrono e
mondi asincroni qui dobbiamo mettere
tutto questo codice di blocco su un I / O
scheduler quindi il primo giro di cose
che abbiamo guardato a fare in modo efficace e
da quando abbiamo iniziato non ne avevamo nessuno di
quella roba reattiva alla pressione
è solo nell’ultimo anno e mezzo
questo è il risultato di circa tre anni
fa quando abbiamo iniziato questo percorso noi
non stavano facendo nulla di tutto questo con questi strumenti
sono a nostra disposizione per un facile collegamento
tra il blocco e il non blocco
mondi così che era la metà inferiore di
questo diagramma per quanto riguarda la metà superiore
la metà superiore era quando le richieste erano
effettivamente entrando nel sistema ed è
una minaccia per il modello di richiesta e questo è
onestamente la parte più difficile della maggior parte
infrastrutture per sbarazzarsi di perché
tutta la tua azienda è pronta per l’implementazione
in qualcosa e cambiando quello
l’infrastruttura è piuttosto non banale in
la maggior parte dei posti e quindi non ci provavamo
e di cambiamento che in attacco stiamo iniziando
per esplorare e io riesco anche a questo e un
un po ‘ma abbiamo avuto a che fare con
il modello servlet per gli ultimi diversi
anni e così questo è il tipico servlet
richieda il ciclo di risposta bene all’interno di quel I
voglio ancora farlo un servizio di sincronizzazione
composizione e così posso dare il via
lavoro e questo lo chiama
metodo asincrono che abbiamo fatto prima con
l’osservabile che dà il via al
stato di spedizione in modo asincrono e nessuno
delle copertine sta facendo tutto asincrono
è tutta la composizione che abbiamo guardato
più tardi quindi questo sta per raggiungere tutto
quegli obiettivi di appiattimento
cascata così che ora tutto sia in grado
accadere contemporaneamente e ottengo il minimo
latenza per gli utenti la differenza
ecco ora che ho bisogno di fare un ponte indietro
da asincrono a sincronizzazione perché altrimenti il
il thread servlet funzionerà correttamente
attraverso e avrò generato il
lavoro in background e poi lo farò
restituire alcune risposte vuote al mio utente
e così potrei andare e mi piace fare il conto alla rovescia
chiusure e tutte quelle cose da solo ma
non è divertente
e così l’osservabile RX offre questo
metodo con un nome molto esplicito per il blocco
è chiamato così che è nel tuo
faccia che tu sappia cosa stai facendo
che sai che stai per rompere
tutte le ragioni del perché hai appena adottato
rx in primo luogo perché altrimenti
che le persone finiscono per tornare al default
la loro imperativa modalità sincrona facilmente
perché è più facile quando sei
prima di iniziare così è come entrare
la tua faccia se vedi due blocchi
il tuo codice sai che stai facendo un passo
fuori dal mondo asincrono che poi permette
di la di ogni su di esso ed è
andando a bloccare il thread servlet per
voi e poi si può colmare di nuovo in
il
mondo e blocco sincrono i / o e
scrivi il tuo risultato e anche
perché a ciascuno di bloccare se per ciascuno
convertito in blocco
mondo convertirà quindi l’errore
messaggi di nuovo in eccezioni generate così
puoi usare il modello try-catch in giro
l’intero blocco di codice e così in questo
modo in cui siamo risaliti da un lavandino a
sincrono in modo che possiamo vivere dentro
questo ecosistema servlet che già
esisteva così due blocchi è il meccanismo
per il collegamento tra asincrono e
sincrono questo è un altro giusto
praticità della libreria da parte di
definizione è praticamente impossibile
avere qualcosa di puro in una piattaforma come
la JVM non è mai stata costruita per assumere
Asincronia al 100% e quindi questi tipi di
le cose ci sono nella biblioteca per consentire
per fare da ponte tra loro
quindi voglio entrare come se fosse
in realtà è andato come abbiamo fatto questo e il
primo tentativo abbiamo effettivamente affrontato Apple
TV Apple TV è stato il primo dispositivo che noi
abbiamo scelto e lo abbiamo riscritto tre volte
ed i primi due erano orribile la
il terzo è ancora cattivo ma ha funzionato e
l’esperienza sentiva come questo va bene che
sono stato io e un altro ingegnere che
facendo la maggior parte del lavoro insieme accoppiato
su di esso e in particolare l’altro ingegnere
era proprio come il diavolo stiamo facendo
questo e io ne avevo avuto un po ‘di a
inizia da lui e apprendi la modella
e noi onestamente avevamo idea di cosa siamo stati
facendo e quello che abbiamo trovato è che la tecnologia
ha funzionato che in realtà si sta muovendo verso questo
il modello asincrono ha effettivamente raggiunto il
obiettivi e che il reattivo
modello di estensioni creato da Eric Meyer
Microsoft in realtà ha funzionato anche nel nostro
orribilmente
cattiva implementazione in Java che esisteva
in quel momento, ma abbiamo imparato alcune cose
lungo la strada e questi sono importanti
per qualcuno di voi per capire se
inizierai a discuterne
percorso nei tuoi stessi ambienti abbiamo dovuto
reimparare molte soluzioni idiomatiche
cose che diamo per scontato che noi
ho appena assunto il là
il modo di fare le cose quando lo sai
ha trascorso la tua intera carriera con il
imperativo si conosce lo stile standard
programmare cose semplici come
iterando un ciclo in modo tale per un ciclo for solo
tipo di dare per scontato la maggior parte di noi
a meno che tu non sia arrivato completamente
percorso diverso da quello che ho fatto e sai
proveniva dallo sfondo funzionale più
persone di cui ho parlato sono venute
sfondi di C e Java e c-sharp
e Python e Ruby ecc. e noi solo
Supponete di scrivere programmi per
loop la cosa è è che in realtà
non funziona quando inizi a trasferirti
la composizione asincrona e funzionale e
cose come loops devono andare via loro
solo loro sono lo strumento sbagliato per cosa
stiamo cercando di raggiungere e quindi abbiamo dovuto
sposta il nostro pensiero per usare invece come
funzioni mappa e dichiarare vai applicare
questo a tutto in questo nel
sequenza e il flusso e quindi abbiamo dovuto
ovunque dovremmo andare naturalmente
pensare a un ciclo for abbiamo dovuto
eliminare la gestione degli errori
completamente diverso in un mondo asincrono
anche così ovunque che avremmo un
try-catch è divertente ho visto il codice
dove le persone avrebbero effettivamente scritto
tutto asincrono e poi hanno messo a
cercare di bloccare il blocco e lo farebbero
chiedo perché i loro errori non siano mai stati scoperti
ed è perché il codice è finito da tempo
e via da qualche altra parte e il tentativo di cattura
è come lì e non ha idea del
l’eccezione è stata lanciata e quindi abbiamo dovuto
completamente smettere di fare qualsiasi nostro errore
maneggiando come quello dovevamo trasferirci
questi modelli di avere effettivamente errori
i gestori che sono in cantiere
i flussi che hanno preso un mentale
ricondizionamento dovevamo anche investire in
documentazione e così abbiamo speso enormi
quantità di tempo e questo è giusto
e abbiamo effettivamente assunto uno scrittore tecnico
David ha commesso una delle migliori decisioni che abbiamo
ha fatto nel progetto e alla fine
elaborato in documentazione come questa
dove abbiamo tutto sul sito web noi
ha iniziato tutto internamente e così
migrato ed evoluto man mano che apriamo
e ti sto dicendo che è fantastico lavorare
con lo scrittore tecnologico siamo ingegneri
sono una brutta descrizione orribile
nel Javadoc o ovunque tu sia
la documentazione è e poi vedrebbe
i commit accadono e lui
piombare dietro di noi e come farcela
in realtà mi sembra ragionevole e leggibile
e lavare fuori e metterlo in esempi
è stato incredibilmente importante come noi
diffondere questo modello diverso attraverso
dozzine di ingegneri perché in realtà
devo imparare di nuovo tutte queste cose anche noi
dovuto consentire il tempo e gli errori
che è stato garantito che accada ho trovato
che una volta un ingegnere stava affrontando a
progetto come questo anche tu dovevi dare per scontato
circa due mesi hai dovuto fondamentalmente
considera che due mesi di tempo per
loro per avvolgere la loro testa intorno ad esso
iniziare a sentirsi naturale scrivendo questo tipo
di codice ed essere disposti a sacrificare il bene
pezzi di quel tempo, una volta a superare
quella gobba
quindi è la navigazione tranquilla per la maggior parte
parte devo anche parlare di unità
test e debug di queste cose
sempre venire e così l’unità di test
in realtà è un buon test unitario asincrono
in realtà può funzionare abbastanza bene così voglio
per mostrare alcuni modi in realtà in realtà
supporta test subito fuori dalla scatola
e con il sottoscrittore del test quel blocco
di codice al di sotto 100% asincrono se tu
esegui un normale come un’unità J o scegli il tuo
qualunque sia la struttura che preferisci, noti
sono sempre assumono sempre
esecuzione sincrona perché se tu
dovevo solo gestirlo senza bloccare
qualcosa che il tuo test unitario avrebbe superato
mentre il lavoro sta davvero accadendo
da qualche altra parte va bene e il test unitario o
fallirebbe perché non ce n’è
il lavoro è lì ma non lo sarà
avere ragione
quindi ti iscrivi ad esso con questo test
abbonato e quindi fornisce solo
aiutanti per poter dire che voglio
attendi un evento terminale quindi blocca il
thread corrente fino a un evento terminale
si verifica con successo o
affermare erroneamente che non c’è
errori e poi fare le asserzioni di
tutto ciò che hai accumulato così il test
l’abbonato si occupa dell’accumulo
i dati sono tutti in modo sincrono
permette anche agli abbonati di testare
per passare come osservatori derisi
come se si volesse usare maketo o
qualunque cosa e così ti permette di combinare
tutti quegli strumenti insieme così puoi
effettivamente mescolare e abbinare asincrona e
il sincrono nei test unitari diventa uniforme
meglio però con tempo virtualizzato così
stesso sottoscrittore di test tranne che sto andando a
aggiungi questo nuovo programmatore di test quindi qualcosa
interessante che Eric Meyer
quando ha progettato estensioni reattive è
ha fatto in modo che tutta la concorrenza
ogni volta si aggiunge la concorrenza del
sistema è sempre parametrizzato e così
tutto il tempo è virtuale, non è mai realmente
chiede il tempo di esecuzione che ore sono
chiede sempre un programmatore e il
lo scheduler può sempre essere iniettato e così
quello che ci permette di fare qui è quello
quella volta l’unità di tempo in millisecondi
che stiamo incrementando di tutto il
improvviso ci consente di prendere il controllo del tempo
e così possiamo far avanzare il tempo in un parente
modo da 200 millisecondi
deterministicamente possiamo quindi affermare
che ha emesso un oggetto come vorremmo
mi aspetto quando ticchetta e poi posso anche
fare assolutamente aumentare in anticipo il tempo
tempo fino a mille millisecondi e
asserire che ho ricevuto il cinque
valori e ora con un test unitario che ho
due vantaggi molto forti
Quello che non devono più avere come un matto
lunghi test di unità dove sto aggiungendo come
secondi di tempo di sonno solo per provare e
come soddisfare tutte le diverse macchine
nel mondo potrei scrivere dirigere la mia unità
prova per cercare di farlo in modo che non sia vivace
e così è deterministico ma lo è
anche così funziona così veloce come la CPU
crunch può attraverso di essa e le mie prove sono
sempre deterministico lo farà sempre
esattamente la cosa giusta perché è
tempo di incremento in un deterministico
modo questo è incredibilmente potente
strumento se hai a che fare con l’asincronia
questo stesso comportamento ci permette anche di
effettivamente guardare flussi storici di
dati e poi crunch su di loro in come
veloce come possiamo applicare lo stesso
operatori temporali a loro come se noi
avrebbe fatto in tempo reale sul
altro debug async mano fa solo schifo
questa è solo la realtà di dove siamo
nel settore in questo momento lasciami solo
vi mostrerà alcuni esempi di quanto è fatto male
quindi impilare le tracce di agnello non fa altro che distruggere
tutto ciò che sono completamente
confuso, non hai idea di cosa sta succedendo
quando pianifichi qualcosa
in modo asincrono solo il thread nativo
sa che era in programma che ha no
idea di cosa ha programmato così hai
completamente perso la catena che ti ha preso
a questo punto
accumulare inquinamento ovunque vedi tutto
è il codice della libreria per la maggior parte
quasi nessun codice utente lì quindi Rx
prova a cercare di dirti qui che hey
Ho avuto un errore quando ho fatto questo
cosa è il
tipi che ti possono piacere tipo di scoperta
a modo tuo, ma questo è solo un
rovina il tuo passo il debugger
attraverso il codice per cui probabilmente non funzionerà
sei in cima lì se davvero
impostare un debugger e cercare di seguire quel
stai davvero andando avanti
il livello esterno come dichiari, ma lo è
mai andare a ottenere effettivamente nella vostra
codice utente in modo da entrare nel codice utente
in realtà devi mettere un punto di interruzione
proprio nel lambda dove vuoi essere
ma è come se tu non lo fossi davvero
passo su e giù questo è solo che è
la natura del codice asincrono oggi e così noi
finiscono per fare un sacco di debug via
registrazione e questo tipo di fa schifo ma è
la realtà di dove siamo ora questo
in realtà non è poi così lontana da dove
eravamo comunque perché distribuiti
sistemi in cui lavoriamo
sistemi distribuiti e così abbiamo tipo di
rinunciato a tutti gli strumenti di debug per
la maggior parte parte comunque, ma questo fa davvero
succhiare quando stai facendo lo sviluppo locale
e questa è solo la realtà che non conosco
nascondi quindi stiamo esplorando il lavoro
qui come abbiamo concettualmente
costruito stack di chiamate logiche che sono
davvero bello quel luppolo che filano proprio loro
uccidere le prestazioni di come due ordini di
la grandezza genera tracce di stat
ovunque ci sia un’azienda che siamo
lavorando con il suo ha fatto un prototipo in
uno spazio che stiamo esplorando potendo
fare alcune cose come nel profondo del
JVM per unire insieme lo stack logico
tracce che attraversano le nostre
frontiere se quel lavoro matura e
diventa utile lasceremo sicuramente il
mondo sapere a questo proposito mi piacerebbe davvero
per le piattaforme iniziare a risolvere questo
problema che è davvero il posto in cui
ha bisogno di essere risolto così come ha fatto tutto questo
guarda una volta che è stata fatta l’API osservabile
ha funzionato bene in quella facciata asincrona e
siamo stati in grado di passare dalla chiamata
modelli come il top in cui abbiamo avuto
tutto sincrono ed era tutto
la concorrenza era in realtà solo perché
i nostri dispositivi ci chiamavano molto eravamo
in grado di far crollare la quantità di
Chiamate di rete e spingere la maggior parte di quel lavoro
al lato server e farlo essere lo stesso
la gestione degli errori era uno sviluppatore corretto
la produttività, dopo che questo ostacolo di
allenarsi era buono e ci siamo trasferiti
da un’API di blocco a un’API osservabile
e tutto il traffico Netflix
il piano di controllo passa attraverso
il traffico osservabile come questo assolutamente
ogni richiesta di servizio web che alimenta
i nostri occhi ci passano attraverso questo
niente a che fare con il video reale
streaming per vedere DNS che è un intero
bestia diversa che sta solo andando a prendere
byte fuori da un CDN ma dal piano di controllo
tutti i nostri servizi Web inviano tutti
attraverso questo tipo di API c’erano
sfide da solo lungo la strada però così
uno di loro troppi thread okay
come se avessi un sistema simile
oltre 1.400 thread su una scatola di otto core
basti pensare a questo ora i benefici
di controbilanciare i contro per la base
la base di codice che stiamo bene
tuttavia è stato reso difficile
per sintonizzare la cosa in shedload che abbiamo realizzato
è molto più difficile che in realtà siamo abbastanza bravi
a questo, ma mi sembra di avere solo ottanta anni
per cento del modo lì e noi no
pensa che possiamo ottenere l’ultimo venti percento
è come questa magica arte nera da immaginare
fuori a che punto cade la scatola e
muore perché non è mai CPU al 98%
è come il 73% in alcuni giorni 62 altro
l’ 84 percento dei giorni dipende tutto
il modo in cui il vento soffia e che
i thread stanno facendo qualcosa e questo è un
la sfida di questo modello è anche davvero
facile da bloccare accidentalmente asincrono
codice e quindi, in questo esempio abbiamo
due modelli simultanei in alto a
sequenziale in basso quello acceso
il fondo farà questo passo cascata
ed era solo un errore dell’utente perché il
differenza una mappa piatta e mappa completamente
rompe tutto perché sul fondo
uno whoops e quello inferiore sono
invocando una chiamata bloccante e quindi cosa noi
in realtà abbiamo fatto qualcosa
fatto in modo che abbiamo appena eliminato tutto
il blocco delle chiamate nella nostra API in modo che noi
reso davvero difficile che tu in realtà
devi coscientemente uscire dalla tua strada
per farcela, il fatto è che c’è
non c’è una corretta modularizzazione in java
gli sviluppatori commettono errori è davvero
facile da infilare nel vecchio modello così è
basta un semplice blocco e chiamalo restituisce
T e abbiamo visto nel codice di produzione come
questo esce e tutto ad un tratto noi
distruggere le prestazioni su qualcosa e il nostro
I canarini devono trovarlo o se è un
piccola cosa non la troviamo troppo tardi
questo è un problema con mescolare le cose in
un ambiente che non è costruito per questo
così lungo il modo in cui iniziamo a chiedere o così
Che cosa succede se abbiamo fatto fare lo sforzo di andare
come fare una riscrittura verde di questo
strato e quello che ho trovato era mito e
leggenda ovunque era come vicino
impossibile ottenere risposte dirette
qualsiasi cosa e vado alle aziende che chiedono
quindi perché hai adottato qualcosa di simile
Metis o qualsiasi altra cosa e ottengo questa risposta
Sono davvero perché è meglio
che questa è una risposta come quella che è
non utile o ho capito che è peggio di non farlo
come assolutamente non farlo
distrugge completamente tutto o è
lo strumento sbagliato per il lavoro tutto questo
roba che avrei preso anche non importa
come qualsiasi cosa tu preferisca e così via
Ho ricercato sempre più e più volte
fondamentalmente trovato che tutti questi diversi
approcci per affrontare la concorrenza
teoricamente dovrebbero tutti fare il
stessa cosa per cui se si bollire il tutto a
ad un certo punto hai le stesse CPU di
stessa memoria lo stesso come fisico
risorse se tu se tutta la programmazione
e qualunque astrazione tu abbia usato
per tagliarlo e tagliarlo nello stesso modo
modo efficiente con cui le astrazioni dovrebbero
teoricamente tutto equivale al
la realtà però non è così, ma questo è
dove molta della confusione che affronto
sarebbe arrivato come per esempio c’è un
articolo sui thread utente che conosci io
non dovrebbe essere necessario utilizzare le callback perché
dei miei thread utente è giusto
l’astrazione è come quello che è morto
fantastico se il mio runtime lo avesse effettivamente dato
per me in un modo che ha funzionato, ma è così
non è l’unico accordo che ho ottenuto
da parte di chiunque lo è se ci stai provando
risolvere il problema 10k mare che è
10.000 connessioni simultanee su una scatola
e quello era un decennio fa o come adesso
è come cento K o un milione che ho
anche io conosco persone che sono decisamente
eseguendo un milione di connessioni simultanee
su una scatola in produzione oggi sono ora
iniziando ad affrontare dieci milioni che
mi sconcerta, non ho dubbi che lo faremo
arrivare lì questo è l’ unico posto che io
ho ottenuto un accordo che sì, vai all’evento
si avvicina a un I / o non bloccante per quelli
le cose sono l’unico posto dove posso arrivare
alle persone piace non discutere con me e così via
Ho avuto questo problema che mi piaceva quello che sono
Scommetto il futuro di una bella
sistema importante e Netflix su e io
non volevo che fosse basato sul mito e
leggenda o budella di Jack o opinioni o simili
sai
tutta quella roba e così abbiamo fatto tutto
cattivo ingegnere, abbiamo scritto un punto di riferimento
e disastroso, naturalmente, ma lo dirò
perché, in un secondo, perché questo è effettivamente
interessante quindi abbiamo creato questa cosa
dove ci manca c’è come il
servizio web stereotipato su Netflix
dove qualcosa entra ti mette in moto
un po ‘di lavoro e poi come quel lavoro arriva
torni a dare un po ‘di più e poi
un po ‘di più e poi lo componi tutto
insieme nel totalmente inefficiente
JSON e io usiamo espressamente JSON in questo modo
In realtà ero realista perché provavo come
Potremmo in realtà non usare un intero
molto efficiente tipo di codifica binaria
cose che sto cercando di ottenere
dei nostri sistemi lì, ma onestamente di più
di questo tipo di cose è il
realtà e non siamo una iper latenza
azienda guidata e quindi la maggior parte del tempo
è abbastanza buono e così questo
tutta la cosa dovrebbe richiedere altri 150 154
millisecondi in una perfetta esecuzione di
e la maggior parte sta solo aspettando l’I / O
molto poco è in realtà
calcolo e onestamente molto poco di
tutti i servizi che vedo stanno facendo
qualsiasi computazione diversa dalla nostra
serializzazione inefficiente e
deserializzazione di swill che inviamo
attraverso il filo e così abbiamo testato questo in
il cloud e tutto quel genere di cose ma
alla fine noi beta abbiamo fatto proprio come nude
metallo quindi possiamo averne un po ‘
dati interessanti fuori di esso e l’unico
motivo per cui ho fiducia e
la fiducia in questi numeri è perché io
ho lavorato con Brendan Gregg e
Brendan Gregg ha scritto un libro
quello spesso è come due pollici di spessore
assistente alla performance ed ero davvero
fortunato di averlo a Netflix al lavoro
con questo e ci sono voluti mesi e
mesi e mesi da ciò che ho imparato
questo è se davvero andrai e
prova a rispondere a questo tipo di domande
intenzione di perdere un sacco di tempo se siete
in realtà intenzione di andare a cercare di fare fare
benchmark e abbiamo usato solo Tomcat
niente come niente di interessante o interessante
realmente e quindi ecco la prima delle
presentazione sui dati che eravamo in realtà
in grado di spingere entrambi fino a quasi
tutto l’utilizzo della CPU ora quando siamo prima
iniziato non siamo riusciti a ottenere Tomcat da nessuna parte
vicino a quello che in realtà abbiamo dovuto spendere due
settimane semplicemente sintonizzando Tomcat per essere in grado di
max out the box che è il primo segno
in realtà piace a Neddie
non avevamo configurato niente , ma funziona
che in realtà è un buon segno, ma Tomcat
siamo stati in grado di ottenerli entrambi
punto qui è dove inizia a prendere
Interessante Nettie ha una CPU inferiore
consumo per richiesta e mantiene
sempre più veloce sotto carico spiegherò
che in un po ‘così perché così
Nettie raggiunge sicuramente più in alto
throughput notevolmente e siamo stati in grado
per dimostrare che questo è principalmente perché
di minor consumo di CPU per richiesta noi
sono stati in grado di tenere traccia di ciò in tutto il
metriche stavamo usando grafici di fiamma e
statistiche e cose diverse nella media
latenza ora latenza media fa schifo è
totalmente inutile non usarlo è solo
interessante su questo grafico per vedere anche
come la media risolve la media
la latenza qui per Nettie è migliore di
Tomcat ma questo è dove arriva
interessante che inizi a guardare al massimo
latenza e sono come il 99 9 e
99 ° 90 ecc., Quindi non solo abbiamo
così tanto tempo oggi, quindi non posso mostrarvi
tutte quelle cose, ma quando inizi
entrambi sono effettivamente in linea
e ciò che la cosa interessante qui è
in realtà inizia a confermare il
premettiamo che teoricamente questi due
dovrebbe comportarsi e ottenere la stessa cosa
e quando il sistema non è sotto carico
in realtà tiene fuori tutti e due
efficacemente comportato lo stesso per quanto riguarda
l’utente prova la latenza su di loro quando
il sistema non è sotto carico durante la rampa
il Tomcat cade e così via
diamo un’occhiata a cosa sta succedendo
istruzioni reali per ciclo per Nettie
che è un evento del modello di ciclo un evento
loop procore in realtà ottiene di più
efficiente come hai messo sotto carico questo era
affascinante per guardare Nettie diventa più veloce
mentre lo spingi più forte, ok
migrazioni thread è stato davvero dove
ha iniziato a mostrare cosa stava succedendo e
così all’inizio abbiamo scelto di non appuntare
discussioni o qualcosa del genere
questo non è il mondo in cui viviamo
lo stiamo esplorando ma non lo ottimizziamo
a quel livello quindi lasciamo il funzionamento
sistema solo pianificare le cose e quando
è sotto carico leggero ogni volta un evento
Era il ciclo o il thread per richiesta
invocato stava ancora programmando
roba e così entrambi stavano migrando
discussioni e sempre bene quando si inizia
per essere sotto carico attraverso il ciclo degli eventi
iniziano a scaldarsi e in realtà iniziano
fare la cosa giusta
e basta iniziare a tubare tutto
e quindi è pensato allo schedulatore
smesso di migrare smesso di spostarli
intorno a dove è il modello Tomcat è tutto
ogni volta che fa un evento richiesto
pianificare un thread che preleva un core mette
su di esso e così le migrazioni dei thread
diventa una cosa importante con Tomcat, quindi perché
Tomcat era più veloce e più efficiente e
perché ha scalato meglio tutte quelle cose
il primo appena codice migliore di Nettie
di Tomcat come se potessimo effettivamente vedere
nel nostro profilo che era molto meglio
ottimizzato per l’assegnazione di oggetti e
quei tipi di cose che ho appena più piccolo
pile hanno fatto di tutto per non farlo
allocare memoria quei tipi di cose
l’architettura del ciclo degli eventi anche se noi
sono stati in grado di dimostrare effettivamente fatto
impatto sulle migrazioni di thread ridotte
che a sua volta influenza il calore della cache
istruzioni sulla memoria per ciclo
e alla fine la cosa che eravamo
in grado di tracciare sin dall’inizio più in basso
Consumo di CPU per ciclo e poi noi
sono stati in grado di individuare nel thread poveri
architettura quantità non trascurabili di tempo
che sono stati spesi per contesa della serratura e
migrazioni di thread
ci sono molti più dati dietro questo
di quanto Brendan Greg potesse parlare di questo
molto più interessante di me cosa noi
sono stati in grado di determinare da esso però è
che nonostante tutte le teorie con
attuali implementazioni JVM e Linux
c’è un vantaggio per noi per adottare il
event loop architecture e anche noi
trovato attraverso questo tutto ciò che era
interessante per me
Ho trovato molto più semplice scrivere e
operare il modello del ciclo di eventi rispetto al
centro commerciale thread non è più facile anche se più facile
è più facile per me fare quello Tomcat
perché è lì che ho 15 anni
della storia farlo quindi devo piace
in realtà pensare di più l’evento di un
e anche i nostri strumenti di succhiare a trattare con
che come noi non abbiamo non abbiamo 20
anni di strumenti attorno agli eventi in
Infatti ho scoperto che ha funzionato tipo
esattamente allo stesso modo della latenza
curva è lo sforzo per ottenere Tomcat
andando è piuttosto accomodante e poi
quando hai effettivamente provato a ridimensionare il
cosa e si sintonizza bene e mi piace come
ha gettato il carico di tutta quella roba perché il
la difficoltà è esattamente come la sua
curva di latenza quindi abbiamo trovato che completamente
l’architettura asincrona ha dei vantaggi
abbastanza sufficiente da iniziare
uno sforzo enorme per andare e
riscrivi il nostro front-end
e migrare fuori dal centro commerciale tommcatt
oltre a Eddy e la cosa interessante
era in realtà non era il the
guadagni di throughput che alla fine hanno guidato
in questo modo potremmo investire denaro
risolvendo possiamo scalare orizzontalmente per noi
il motivo che ci ha spinto è stato il
vantaggi operativi il fatto che io possa
spingere quella cosa fino al 98 99% e
ancora fidati di come sarebbe andata la mia macchina
eseguire la disponibilità e l’esperienza dell’utente
i benefici sono molto più importanti per noi
di quanto possiamo solo buttare soldi alle macchine
è più economico degli ingegneri
questo, ma la disponibilità e le operazioni sono
una programmazione così reattiva può essere
applicato in modo incrementale ma viene
con le sfide quando si mescolano
basi di codice
concorrenza da un servizio di sincronizzazione
la composizione è stata nel nostro ambiente
su vasta scala per molti anni di gestione di questo
con dozzine di ingegneri di vario tipo
livelli di esperienza con esso ha funzionato
davvero bene per noi siamo molto contenti
questo rx Java orari e thread possono
essere sfruttato per colmare tale lacuna in
realtà anche se usiamo solo distretti
per questo motivo la storia è colpa nostra
il nostro livello di gestione dei guasti è fondamentalmente
fa intestazione di massa e tutto quel tipo di
roba in realtà ne facciamo uso
tutta quella roba che ci avvolge bloccando
I / O si occupa con esso aggiunge il
thread e simultaneità e intestazione
e metriche e tutte queste cose così noi
in realtà non fare nulla di tutto ciò direttamente
codice che ti ho mostrato prima così noi
basta mettere tutto in uno strato in
isterici piuttosto che ovunque nel nostro
codice ripetendo la stessa cosa sopra e
di nuovo in chiusura concorrenza è
comunque è ok non banale che non lo è
andare via la nostra X non prova e
banalizzare ogni tentativo che abbia mai fatto
visto per astrarre completamente quella roba
di distanza e rendono banale e facile ottiene
circa l’80% del modo in cui ci sei e poi tu
devo perforare il lato ad un certo punto
e rompere completamente il sistema e io
ho scoperto che finora non ho visto
una soluzione là fuori che risolve
concorrenza e asincronia in un modo
puoi ignorare completamente ciò che sta succedendo
su sono astrazioni che perdi hai
per capire ancora cosa sta succedendo
Rx è una libreria non un framework così tu
applicalo dove è necessario non lo fa
prendi il tuo ecosistema e
è stato importante per noi non lo siamo
lì non me lo aspetto mai
vedere una cella per un sistema del genere ma io
credo che siamo in procinto di
per lo meno essere oh forse tira quei piccoli
astronavi lassù e come portarle
a New York ora forse sembro
Vendicatori e c’è molto di più
le informazioni qui sono finite ed è
più di tutto di cui ho parlato è tutto
open source e prenderò domande se
avete
tu
è piuttosto raro che io abbia l’opportunità
pieno di un pisolino come molto raro che nessuno
di noi arrivare a fare questo forse gli piace
piccole cose ma nessuno dei nostri grandi sistemi
forse pensi che sia così forse
è così che pensi che la tua app appaia ma
probabilmente la maggior parte di voi è la vostra app di più
così è davvero molto
sofisticato è molto potente
facendo un sacco di cose bene è in esecuzione
affari nel mio caso abbiamo sistemi
costruito e gestito un miliardo di dollari
business a livello globale e questa è una foto
di New York
okay, New York è stata costruita sopra
decenni e l’infrastruttura di esso
serve uno scopo ma come noi come è cresciuto
intorno ad esso una città importante come questa
ha la sfida di come iniziamo
modernizzare alcuni aspetti di esso in un
modo economicamente vantaggioso senza strappi
la città perché non è solo la realtà
ora se la tua app è come quella che puoi
alzati e lascia che non hai bisogno di me
mai effettivamente visto un’app come questa se
hai visto quei fumetti di simili
un ingegnere e architetti che conosce
questa volta ho intenzione di farlo bene e
hanno questa visione e poi piace
sei pannelli dopo è tutto ciò che abbiamo fatto
ancora una volta il mio obiettivo è quello di prendere forse
alcuni degli aspetti di questo e portare
torna a New York City okay
così pochi anni fa abbiamo avuto un risultato molto semplice
Caso d’uso che stavamo cercando di raggiungere
volevamo avere una sola chiamata di rete
vieni dai nostri dispositivi e poi
sfruttare la rete a bassa latenza del nostro
infrastruttura lato server e
concorrenza che era disponibile a noi su
i nostri potenti server al contrario di
lasciando piccoli dispositivi mobili o economici
come scatole da $ 30 e perché Netflix
distribuisce a tutto ciò che attacca un
schermo e quindi abbiamo tutto
giù a come il 20 e 30 dollari
silicio e fino al multi
cento o più migliaia di
dollari di attrezzature che abbiamo
tutto in mezzo e il più economico
dispositivi che non riescono a gestire tutti
la concomitante composizione di tutto il
servizi web quindi volevamo spingere tutti
quel lato server così lungo il nostro cammino
capito che per farlo efficacemente noi
voluto essere in grado di abbracciare un noi asincrona
necessario per farlo nel modo più naturale
in modo ovvio
facciamolo chiamata spalle chiamano spalle
efficacemente è ciò che tutto bolle
giù
– ad un certo punto ne metti un sacco
ostruzioni in cima ma a un certo punto
il lavoro finisce e ti dice quando
è fatto e si richiama in
realtà dei casi d’uso che stavamo provando
risolvere per con composizione di servizio così
vogliamo comporre più servizi
insieme senza rinunciare all’errore
gestione e produttività degli sviluppatori e
in realtà molte soluzioni che vanno
lungo il percorso asincrono finiscono per sacrificare a
molto in queste due aree e quindi c’era
abbastanza di noi nella squadra che aveva
sperimentato quel dolore che non abbiamo fatto
solo in fretta, percorro questa strada che ero
abbastanza fortunato che ho avuto un sacco di
diversi ingegneri intorno a me da
sfondi diversi e uno di loro
era Jeff er Hussain da cui proveniva
Microsoft che ha trascorso un paio di mesi
litigare con me per picchiarmi fino a quando
Ho ammesso che aveva ragione ed è così
come sono stato introdotto nel reattivo
spazio di programmazione quindi abbiamo scelto di adottare
asincrono ma per farlo senza chiamata raw
spalle così se guardo Java così com’è
la maggior parte di Netflix è in esecuzione sulla JVM
e la maggior parte di questo è ancora solo giocando
Java e sempre di più è Java 8
per fortuna il futuro e il futuro della lista
di tè con quelle due cose che potremmo
in realtà indirizzano molti dei nostri casi d’uso
ma onestamente quella lista di T in un futuro
non è esattamente giusto perché siamo ancora
devo aspettare per l’intera cosa
completa prima che ritorni e anche a
il tempo in cui abbiamo iniziato questo percorso
Futures Java hanno appena visto che tu
in realtà non li puoi comporre tu finisci
bloccando le discussioni su di loro non lo farò
approfondisci oggi le liste
sono in realtà qualcosa abbiamo a che fare con questo
è l’esempio stereotipato di un elenco di
liste di film e questo è per fare
come la griglia sulla home page e così abbiamo
scorrere l’elenco delle liste e quindi
al suo interno iteriamo su tutto il
film all’interno di un elenco e quindi all’interno
che andiamo a prendere un sacco di roba
e così se fate questo ingenuamente si finisce
con due cose
centinaia di chiamate di rete e anche tu
finire con una funzione di passaggio come a
cascata che continua ad andare avanti
per sempre e così è stato esattamente noi
non volevo
è successo c’è anche questo caso
che non avresti mai fatto con a
normale futuro questo futuro elencare il
futuro del tè ma semanticamente è così
in realtà ciò che volevamo, vogliamo calciare
fuori da questo lavoro in modo asincrono che sarebbe
essere in grado di rimandare a noi singoli
oggetti lungo la pipa come sono venuti ed essere
in grado di lavorare su di loro come sono arrivati
quindi lo sapevamo già semanticamente
questo è quello che volevamo fare proprio questo
non era giusto e siamo finiti lì
modi diversi di gestire questo ma noi
finito per adottare l’osservabile RX
scrivi in modo che la nostra X sia sinonimo di reattivo
estensioni nel nostro prescrizione che
potrebbe essere una prescrizione per Java non lo faccio
sappi ma questo le estensioni reattive
per Java ci ha dato questo tipo osservabile
e abbiamo finito per trattare tutto come un
in streaming quindi solo tutti i dati che arrivano in questo
è solo un flusso di dati, che sia
un oggetto molti oggetti o un infinito
flusso di dati che abbiamo appena iniziato a trattare
tutto come un flusso quindi cosa è cosa
la nostra API sembrava al momento
tutto ciò stava bloccando le chiamate API come
che ora non ci occupiamo molto
ordina prodotti e lo stato della spedizione ma
Ho deciso di usare qualcosa di diverso da
rispetto agli ismi Netflix che io
in genere uso e in questo caso si recupera
tutti gli ordini e poi per ogni ordine
vai a prendere tutti i prodotti e per ciascuno
prodotto si preleva la spedizione
stato così quando vado al mio amazon.com
pagina Vedo cose simili come questa okay
questo è molto comune come praticamente tutti
sito di commercio che ho mai usato ha un po ‘
pagina che viene renderizzata dietro il
scene che posso immaginare questo flusso
succede e l’API è sotto di esso
che stiamo usando questi sono tipici
l’ API di blocco è che siamo stati tutti
usando per sempre bene, il problema è questo
se lo metti insieme in modo ingenuo
si finisce con l’attraversamento di questo
uno stile cascata in ogni spedizione
chiamate di stato diciamo 100 millisecondi
Ho capito qui così puoi solo visualizzare
e tu lo attraversi e c’è
assolutamente nessuna concorrenza in corso
qualsiasi
ora sto bene con Java
Concorrenza in pratica prenota quel treno
il libro è seduto sulla mia scrivania è uno di
solo due libri ho ancora in carta
forma ed è un ottimo libro ma onestamente
la maggior parte di noi non dovrebbe dover leggere
e anche se ho letto quella cosa
due volte e ancora mi riferisco ad esso ancora
rovinare tutto e
avevamo dozzine di ingegneri e anche noi
un ingegnere dell’interfaccia utente ha fatto un passo
in queste basi di codice e abbiamo appena saputo
che possiamo avere semafori nel nuovo
Texas e mi piace come lanciare discussioni
a caso e tutto quel genere di cose e
aspettandoci che funzioni l’ambiente
stavano lavorando con in questo è ciò che il nostro
pila trattata con tutti i nostri inter
la comunicazione di processo era prevalentemente
fatto con Apache HCP che abbiamo
memcache D ed ecco la cosa triste è
anche se il suo cliente è in realtà
l’esecuzione su un ciclo di eventi ha avuto un blocco
L’API oltre a questo non espone effettivamente il
asincronia BIA al di sotto e così
sei ancora seduto e stai bloccando su un
la chiamata asincrona ha bloccato Cassandra
in Tomcat e servlet come quello è il
mondo in cui eravamo e gran parte dei nostri
la roba continua a bloccarsi e quindi via
la terra ho introdotto un modello reattivo
in una pila come quella e così il
la realtà era che possiamo andare a correre
ricostruire tutto specialmente per
qualcosa che era ingegneri non provati
non stavano ancora comprando l’ idea ma
potremmo cambiare il nostro livello di servizio e così via
c’era uno strato all’interno di questa pila
siamo stati in grado di entrare e di cambiare noi
aveva piena libertà di farlo era
isolato al solo la nostra squadra e abbiamo potuto
iterate su di esso e così abbiamo creato questo
facciata asincrona e abbiamo bloccato proprio dentro
tra le parti che non potevamo
il controllo in alto è il servlet e
Infrastruttura Tomcat che non eravamo
sta per cambiare è che è un intero
cosa diversa ne parlerò
più alla fine della presentazione e
sotto tutto il codice che esegue tutto
la logica aziendale e tutto l’IPC e
tutte quelle cose che non potremmo in nessuna
Il tempo passa presto , quindi quello che abbiamo fatto è stato noi
è passato da un blocco del modello di blocco
API a aspi asincrona che noi
è finito per chiamare api osservabili
perché finiscono tutti per assomigliare
che invece di digitare T è un
osservabile di T e così tutto il nostro intero
livello di servizio è stato commutato a questo
modello in cui tutto il metodo chiama
restituito e osservabile di qualcosa e
ciò che permette questo è molto banale
esempio ma solo per mostrare che il
stato di spedizione ora che era
in modo sincrono invocandolo ancora
lo stesso aspetto di nidificazione così
la semantica è ancora lì, io ancora
vedilo a due livelli come me
non era prima ma ora è seduto
all’interno di un flusso osservabile asincrono che
è all’interno di un altro osservabile asincrono
flusso e il modo in cui questo si comporta ora
quando premo il gioco su questo funziona e poi
tutto scorre dentro perché quello che fa è
facendo in modo che sia tutto asincrono
mi permette di dichiarare quello che voglio io
da fare e quindi il runtime può scegliere
la concorrenza che sta andando a
eseguire a così posso iniziare
sfruttare la concorrenza
capacità della mia macchina e I / O
con cui sto interagendo in modo che il
l’effettiva latenza dell’esperienza utente ora può
essere migliorato in modo significativo, ecco tutto
cose di cui tutti sappiamo bene questo
inizia a darmi gli strumenti per ottenere
Ecco, quindi, come posso davvero ottenere da quello
ottenere il metodo di stato di spedizione che è
bloccando a uno che è asincrono così Rx è un
strumento che usiamo per fare questo tipo di
roba così un modo molto semplice siamo noi
letteralmente avvolgere solo le chiamate di blocco
e quindi c’è un meccanismo in rx an
l’operatore ha chiamato rimandare che siamo
letteralmente dicendo rinviare l’esecuzione di questo
fino a quando non torno più tardi
dichiarare il lavoro da fare quando si è
eseguire eseguire questo blocco di codice che è
seduto qui in una lambda e poi quando
tu corri questo è questo è un
parte importante quando in realtà sono
sottoscritto per iscriversi su questo
scheduler in questo caso lo metti su
un schedulatore di I / O che sta per mettere
su fili che sono là fuori
destinato a essere bloccato con il blocco il
okay quindi non c’è magia qui
stiamo solo aggiungendo discussioni attraverso il nostro
sistema come qualcuno di voi sta per sussultare
e piango e ne parlerò più che più tardi sì
abbiamo centinaia di centinaia di thread
in alcuni dei nostri sistemi ed è triste
triste stato di cose, ma è meglio per
il caso d’uso che avevamo dove è
quasi tutti i / o che erano seduti quando
esegue ciò che invoca quindi ottenere
stato di spedizione in modo bloccante e
blocca che i / o thread e poi quando
alla fine ritorna dice basta prendere
quel valore di T e restituirlo come un
osservabile
quindi cosa succede se ho una lista di ordini I
in realtà non voglio avere questo turno
in un elenco di ordine osservabile perché
che siamo in grado di sconfiggere il punto di quello che ho
stava cercando di raggiungere e così quello
lista di ordine può diventare osservabile di
Ordina così quando ti iscrivo a questo
emette ogni elemento della lista a me
ora non ne sto conseguendo davvero
in streaming ma questo mi sta solo facendo
in un modello di programmazione asincrono la via
che puoi farlo è esattamente lo stesso
l’unica differenza qui è che ho rimandato
iscriviti e ricevi gli ordini che uso
da invece di solo e da solo
converte un iterabile in osservabile
niente di tutto ciò che speciale qui così a
livello base ci siamo letteralmente imbattuti
il nostro sistema di avvolgimento tutto
discussioni e siamo stati in grado di solo con
questa capacità migliora la latenza dell’utente
ma in un modo che potremmo effettivamente
ancora motivo perché lo strumento ha dato
noi la capacità di comporlo andiamo a
un po ‘più lontano se lo sono davvero
lavorando a JDBC che immagino almeno
alcuni di voi hanno ancora a che fare con esso
per fortuna non ho avuto a che fare con
JDBC in quattro anni sono molto felice
che il JDBC è ancora il vero
l’ unico modo legittimo per accedere a
un sacco di database e quindi se il tuo codice
in realtà sta interagendo con JDBC
può iniziare a fare cose diverse così
nel blocco che puoi effettivamente vedere
che si accumulano tutti i dati in un
struttura dei dati come sta tornando così
lo stiamo ritirando dal database
e mentre sta tornando abbiamo accumulato
e questo significa che stavano assegnando
memoria e stiamo anche tenendo l’utente
fino a quando non abbiamo finito di tirare
tutto giù metterlo in un data
struttura diamo loro i dati
struttura li iterano sopra di nuovo e
allora devono buttarlo via e
se tu raccogliessi i rifiuti
passare al modello di flusso osservabile
metti lo stesso codice all’interno di create e
mentre stai ricevendo le risposte
in realtà sei solo sulla prossima cosa a loro
fuori il flusso mentre li ricevi
e così abbiamo completamente eliminato il
bisogno di quel livello aggiuntivo di oggetto
l’allocazione e il buffering solo questo è un
grande gioco perché ora sto solo lasciando
i dati fluiscono attraverso e io posso
reagire ad esso mentre viene trasmesso il
conduttura
piuttosto che buffering in passaggi
lungo il modo in cui il terminale indica
completamento riuscito ed errato
ci sono e questo sta mostrando il ponte
tra un blocco e non blocco
mondo perché JDBC lo sta bloccando
getterò delle eccezioni e devo farlo
li cattura
supporta anche unsubscribed perché in
il mio banale esempio qui ho deciso di
selezionare la stella dalla tabella enterica e
quindi probabilmente non voglio
tira giù l’ intero tavolo e così questo
mi consentirà di annullare l’iscrizione
con grazia e si chiuderà il tutto
in modo che se voglio solo prendere cinque
i valori si risolveranno da soli
pulire e pulire tutte le risorse
invece di succhiare l’intero database
giù e buttando tutto via
e ovviamente perché JBC sta bloccando I
devo metterlo su un programmatore di I / O
ora ti mostrerò di più
esempio complicato e voglio fare
questo in modo che tu possa vedere il potere
come tu che sei lì e questo reattivo
tirare indietro la pressione di stile si è evoluta
di collaborazione nel settore con
come tipo sicuro e fondamentale e Twitter
e altri e ha portato al
specifica dei flussi reattivi che
appena andato 100 di recente e il grande
La cosa su questo è che stiamo ottenendo
la stessa semantica per come fare
streaming con contropressione su molti
diverse società e biblioteche quindi Rx
java è stato coinvolto in questo diritto
fin dall’inizio e quindi sosteniamo la
la semantica e così in java per quelli
di voi che avete la fortuna di lavorare
c-sharp e altre lingue con
async / await
è solo schermare i tuoi occhi che dobbiamo fare
tutto a mano quindi dobbiamo mettere uno stato
macchina in atto per fare questo
async / attendi roba di stile e così vado
per mostrarti un codice che è come il
nel mezzo non ho intenzione di mostrarti il
macchina di stato reale ma sto andando a
mostraci i pezzi di noi e noi siamo
andando a creare un osservabile in questo
particolare astrazione che usiamo solo per
guidare la macchina di stato per noi il
lo stato attuale al suo interno è il set di risultati
che torneremo dal
jvc okay
quando questa macchina a stati inizia il primo
cosa fa è uno stato costruito e
così vedrai che all’interno di esso si ottiene la
connessione al database creiamo il
affermazione corretta
configurazione quindi questa configurazione è
fondamentalmente lo fai in JBC per dirlo a
non tamponare tutto per te così anni
fa quando stavo lavorando con il mio sequel a
è sempre divertente quando sei finito
come gonfiore vostro vostro spazio di memoria a
come 10 concerti perché hai provato a caricare
l’ intero database in questo dice il
Driver JDBC su se il database supporta
per trasmettere i dati a te invece di
tirando giù tutto in buffering
memoria e poi dandolo a te quale
è quando stai trasmettendo grandi quantità
dei dati che vuoi fare questo
specialmente quando stai facendo qualcosa
così che quindi lo stato viene creato
quello che fa è che in realtà ha un
negoziazione bidirezionale tra il
consumatore e il produttore e quando il
il consumatore esprime la capacità di ricevere
dati che richiede i dati alla macchina di stato
invocherà poi questo lambda come molti
volte in quanto ha bisogno di soddisfare questo e così
quando entra in quello recupera il
stato e poi dice se il set di risultati
ha dati e questa è una chiamata bloccante
perché è JDBC quindi emette il prossimo
altrimenti tutto si completa se non c’è
ulteriori dati perché JDBC lo sta bloccando
genererà un’eccezione quindi questo è il
ponte tra il blocco e il non
bloccare i mondi e poi catturerei
che ed emettono l’errore e poi il
importante quando quando lo stato
la macchina si spegne e mi dà
l’ opportunità di terminare e pulire
tutto e quello succede se
è un successo terminante
termine un errore o se ho
annullato l’abbonamento a una risorsa da chiudere
prematuramente passerà sempre
il passaggio di pulizia quindi condivido questo perché
questo è importante per lo streaming di sincronizzazione
sistemi che se non hai questo tipo
di una macchina statale dietro le quinte di te
finisci con il buffer gonfiare o uscire
perdita di dati di memoria cose diverse come
che la pressione posteriore è importante in un
sincronizzare i sistemi nello stesso modo in cui è
sincrono è solo un po ‘più complicato
per avere ragione in un sistema asincrono e così via
questo è un meccanismo per affrontare
quello e certamente perché siamo
colmare tra sincrono e
mondi asincroni qui dobbiamo mettere
tutto questo codice di blocco su un I / O
scheduler quindi il primo giro di cose
che abbiamo guardato a fare in modo efficace e
da quando abbiamo iniziato non ne avevamo nessuno di
quella roba reattiva alla pressione
è solo nell’ultimo anno e mezzo
questo è il risultato di circa tre anni
fa quando abbiamo iniziato questo percorso noi
non stavano facendo nulla di tutto questo con questi strumenti
sono a nostra disposizione per un facile collegamento
tra il blocco e il non blocco
mondi così che era la metà inferiore di
questo diagramma per quanto riguarda la metà superiore
la metà superiore era quando le richieste erano
effettivamente entrando nel sistema ed è
una minaccia per il modello di richiesta e questo è
onestamente la parte più difficile della maggior parte
infrastrutture per sbarazzarsi di perché
tutta la tua azienda è pronta per l’implementazione
in qualcosa e cambiando quello
l’infrastruttura è piuttosto non banale in
la maggior parte dei posti e quindi non ci provavamo
e di cambiamento che in attacco stiamo iniziando
per esplorare e io riesco anche a questo e un
un po ‘ma abbiamo avuto a che fare con
il modello servlet per gli ultimi diversi
anni e così questo è il tipico servlet
richieda il ciclo di risposta bene all’interno di quel I
voglio ancora farlo un servizio di sincronizzazione
composizione e così posso dare il via
lavoro e questo lo chiama
metodo asincrono che abbiamo fatto prima con
l’osservabile che dà il via al
stato di spedizione in modo asincrono e nessuno
delle copertine sta facendo tutto asincrono
è tutta la composizione che abbiamo guardato
più tardi quindi questo sta per raggiungere tutto
quegli obiettivi di appiattimento
cascata così che ora tutto sia in grado
accadere contemporaneamente e ottengo il minimo
latenza per gli utenti la differenza
ecco ora che ho bisogno di fare un ponte indietro
da asincrono a sincronizzazione perché altrimenti il
il thread servlet funzionerà correttamente
attraverso e avrò generato il
lavoro in background e poi lo farò
restituire alcune risposte vuote al mio utente
e così potrei andare e mi piace fare il conto alla rovescia
chiusure e tutte quelle cose da solo ma
non è divertente
e così l’osservabile RX offre questo
metodo con un nome molto esplicito per il blocco
è chiamato così che è nel tuo
faccia che tu sappia cosa stai facendo
che sai che stai per rompere
tutte le ragioni del perché hai appena adottato
rx in primo luogo perché altrimenti
che le persone finiscono per tornare al default
la loro imperativa modalità sincrona facilmente
perché è più facile quando sei
prima di iniziare così è come entrare
la tua faccia se vedi due blocchi
il tuo codice sai che stai facendo un passo
fuori dal mondo asincrono che poi permette
di la di ogni su di esso ed è
andando a bloccare il thread servlet per
voi e poi si può colmare di nuovo in
il
mondo e blocco sincrono i / o e
scrivi il tuo risultato e anche
perché a ciascuno di bloccare se per ciascuno
convertito in blocco
mondo convertirà quindi l’errore
messaggi di nuovo in eccezioni generate così
puoi usare il modello try-catch in giro
l’intero blocco di codice e così in questo
modo in cui siamo risaliti da un lavandino a
sincrono in modo che possiamo vivere dentro
questo ecosistema servlet che già
esisteva così due blocchi è il meccanismo
per il collegamento tra asincrono e
sincrono questo è un altro giusto
praticità della libreria da parte di
definizione è praticamente impossibile
avere qualcosa di puro in una piattaforma come
la JVM non è mai stata costruita per assumere
Asincronia al 100% e quindi questi tipi di
le cose ci sono nella biblioteca per consentire
per fare da ponte tra loro
quindi voglio entrare come se fosse
in realtà è andato come abbiamo fatto questo e il
primo tentativo abbiamo effettivamente affrontato Apple
TV Apple TV è stato il primo dispositivo che noi
abbiamo scelto e lo abbiamo riscritto tre volte
ed i primi due erano orribile la
il terzo è ancora cattivo ma ha funzionato e
l’esperienza sentiva come questo va bene che
sono stato io e un altro ingegnere che
facendo la maggior parte del lavoro insieme accoppiato
su di esso e in particolare l’altro ingegnere
era proprio come il diavolo stiamo facendo
questo e io ne avevo avuto un po ‘di a
inizia da lui e apprendi la modella
e noi onestamente avevamo idea di cosa siamo stati
facendo e quello che abbiamo trovato è che la tecnologia
ha funzionato che in realtà si sta muovendo verso questo
il modello asincrono ha effettivamente raggiunto il
obiettivi e che il reattivo
modello di estensioni creato da Eric Meyer
Microsoft in realtà ha funzionato anche nel nostro
orribilmente
cattiva implementazione in Java che esisteva
in quel momento, ma abbiamo imparato alcune cose
lungo la strada e questi sono importanti
per qualcuno di voi per capire se
inizierai a discuterne
percorso nei tuoi stessi ambienti abbiamo dovuto
reimparare molte soluzioni idiomatiche
cose che diamo per scontato che noi
ho appena assunto il là
il modo di fare le cose quando lo sai
ha trascorso la tua intera carriera con il
imperativo si conosce lo stile standard
programmare cose semplici come
iterando un ciclo in modo tale per un ciclo for solo
tipo di dare per scontato la maggior parte di noi
a meno che tu non sia arrivato completamente
percorso diverso da quello che ho fatto e sai
proveniva dallo sfondo funzionale più
persone di cui ho parlato sono venute
sfondi di C e Java e c-sharp
e Python e Ruby ecc. e noi solo
Supponete di scrivere programmi per
loop la cosa è è che in realtà
non funziona quando inizi a trasferirti
la composizione asincrona e funzionale e
cose come loops devono andare via loro
solo loro sono lo strumento sbagliato per cosa
stiamo cercando di raggiungere e quindi abbiamo dovuto
sposta il nostro pensiero per usare invece come
funzioni mappa e dichiarare vai applicare
questo a tutto in questo nel
sequenza e il flusso e quindi abbiamo dovuto
ovunque dovremmo andare naturalmente
pensare a un ciclo for abbiamo dovuto
eliminare la gestione degli errori
completamente diverso in un mondo asincrono
anche così ovunque che avremmo un
try-catch è divertente ho visto il codice
dove le persone avrebbero effettivamente scritto
tutto asincrono e poi hanno messo a
cercare di bloccare il blocco e lo farebbero
chiedo perché i loro errori non siano mai stati scoperti
ed è perché il codice è finito da tempo
e via da qualche altra parte e il tentativo di cattura
è come lì e non ha idea del
l’eccezione è stata lanciata e quindi abbiamo dovuto
completamente smettere di fare qualsiasi nostro errore
maneggiando come quello dovevamo trasferirci
questi modelli di avere effettivamente errori
i gestori che sono in cantiere
i flussi che hanno preso un mentale
ricondizionamento dovevamo anche investire in
documentazione e così abbiamo speso enormi
quantità di tempo e questo è giusto
e abbiamo effettivamente assunto uno scrittore tecnico
David ha commesso una delle migliori decisioni che abbiamo
ha fatto nel progetto e alla fine
elaborato in documentazione come questa
dove abbiamo tutto sul sito web noi
ha iniziato tutto internamente e così
migrato ed evoluto man mano che apriamo
e ti sto dicendo che è fantastico lavorare
con lo scrittore tecnologico siamo ingegneri
sono una brutta descrizione orribile
nel Javadoc o ovunque tu sia
la documentazione è e poi vedrebbe
i commit accadono e lui
piombare dietro di noi e come farcela
in realtà mi sembra ragionevole e leggibile
e lavare fuori e metterlo in esempi
è stato incredibilmente importante come noi
diffondere questo modello diverso attraverso
dozzine di ingegneri perché in realtà
devo imparare di nuovo tutte queste cose anche noi
dovuto consentire il tempo e gli errori
che è stato garantito che accada ho trovato
che una volta un ingegnere stava affrontando a
progetto come questo anche tu dovevi dare per scontato
circa due mesi hai dovuto fondamentalmente
considera che due mesi di tempo per
loro per avvolgere la loro testa intorno ad esso
iniziare a sentirsi naturale scrivendo questo tipo
di codice ed essere disposti a sacrificare il bene
pezzi di quel tempo, una volta a superare
quella gobba
quindi è la navigazione tranquilla per la maggior parte
parte devo anche parlare di unità
test e debug di queste cose
sempre venire e così l’unità di test
in realtà è un buon test unitario asincrono
in realtà può funzionare abbastanza bene così voglio
per mostrare alcuni modi in realtà in realtà
supporta test subito fuori dalla scatola
e con il sottoscrittore del test quel blocco
di codice al di sotto 100% asincrono se tu
esegui un normale come un’unità J o scegli il tuo
qualunque sia la struttura che preferisci, noti
sono sempre assumono sempre
esecuzione sincrona perché se tu
dovevo solo gestirlo senza bloccare
qualcosa che il tuo test unitario avrebbe superato
mentre il lavoro sta davvero accadendo
da qualche altra parte va bene e il test unitario o
fallirebbe perché non ce n’è
il lavoro è lì ma non lo sarà
avere ragione
quindi ti iscrivi ad esso con questo test
abbonato e quindi fornisce solo
aiutanti per poter dire che voglio
attendi un evento terminale quindi blocca il
thread corrente fino a un evento terminale
si verifica con successo o
affermare erroneamente che non c’è
errori e poi fare le asserzioni di
tutto ciò che hai accumulato così il test
l’abbonato si occupa dell’accumulo
i dati sono tutti in modo sincrono
permette anche agli abbonati di testare
per passare come osservatori derisi
come se si volesse usare maketo o
qualunque cosa e così ti permette di combinare
tutti quegli strumenti insieme così puoi
effettivamente mescolare e abbinare asincrona e
il sincrono nei test unitari diventa uniforme
meglio però con tempo virtualizzato così
stesso sottoscrittore di test tranne che sto andando a
aggiungi questo nuovo programmatore di test quindi qualcosa
interessante che Eric Meyer
quando ha progettato estensioni reattive è
ha fatto in modo che tutta la concorrenza
ogni volta si aggiunge la concorrenza del
sistema è sempre parametrizzato e così
tutto il tempo è virtuale, non è mai realmente
chiede il tempo di esecuzione che ore sono
chiede sempre un programmatore e il
lo scheduler può sempre essere iniettato e così
quello che ci permette di fare qui è quello
quella volta l’unità di tempo in millisecondi
che stiamo incrementando di tutto il
improvviso ci consente di prendere il controllo del tempo
e così possiamo far avanzare il tempo in un parente
modo da 200 millisecondi
deterministicamente possiamo quindi affermare
che ha emesso un oggetto come vorremmo
mi aspetto quando ticchetta e poi posso anche
fare assolutamente aumentare in anticipo il tempo
tempo fino a mille millisecondi e
asserire che ho ricevuto il cinque
valori e ora con un test unitario che ho
due vantaggi molto forti
Quello che non devono più avere come un matto
lunghi test di unità dove sto aggiungendo come
secondi di tempo di sonno solo per provare e
come soddisfare tutte le diverse macchine
nel mondo potrei scrivere dirigere la mia unità
prova per cercare di farlo in modo che non sia vivace
e così è deterministico ma lo è
anche così funziona così veloce come la CPU
crunch può attraverso di essa e le mie prove sono
sempre deterministico lo farà sempre
esattamente la cosa giusta perché è
tempo di incremento in un deterministico
modo questo è incredibilmente potente
strumento se hai a che fare con l’asincronia
questo stesso comportamento ci permette anche di
effettivamente guardare flussi storici di
dati e poi crunch su di loro in come
veloce come possiamo applicare lo stesso
operatori temporali a loro come se noi
avrebbe fatto in tempo reale sul
altro debug async mano fa solo schifo
questa è solo la realtà di dove siamo
nel settore in questo momento lasciami solo
vi mostrerà alcuni esempi di quanto è fatto male
quindi impilare le tracce di agnello non fa altro che distruggere
tutto ciò che sono completamente
confuso, non hai idea di cosa sta succedendo
quando pianifichi qualcosa
in modo asincrono solo il thread nativo
sa che era in programma che ha no
idea di cosa ha programmato così hai
completamente perso la catena che ti ha preso
a questo punto
accumulare inquinamento ovunque vedi tutto
è il codice della libreria per la maggior parte
quasi nessun codice utente lì quindi Rx
prova a cercare di dirti qui che hey
Ho avuto un errore quando ho fatto questo
cosa è il
tipi che ti possono piacere tipo di scoperta
a modo tuo, ma questo è solo un
rovina il tuo passo il debugger
attraverso il codice per cui probabilmente non funzionerà
sei in cima lì se davvero
impostare un debugger e cercare di seguire quel
stai davvero andando avanti
il livello esterno come dichiari, ma lo è
mai andare a ottenere effettivamente nella vostra
codice utente in modo da entrare nel codice utente
in realtà devi mettere un punto di interruzione
proprio nel lambda dove vuoi essere
ma è come se tu non lo fossi davvero
passo su e giù questo è solo che è
la natura del codice asincrono oggi e così noi
finiscono per fare un sacco di debug via
registrazione e questo tipo di fa schifo ma è
la realtà di dove siamo ora questo
in realtà non è poi così lontana da dove
eravamo comunque perché distribuiti
sistemi in cui lavoriamo
sistemi distribuiti e così abbiamo tipo di
rinunciato a tutti gli strumenti di debug per
la maggior parte parte comunque, ma questo fa davvero
succhiare quando stai facendo lo sviluppo locale
e questa è solo la realtà che non conosco
nascondi quindi stiamo esplorando il lavoro
qui come abbiamo concettualmente
costruito stack di chiamate logiche che sono
davvero bello quel luppolo che filano proprio loro
uccidere le prestazioni di come due ordini di
la grandezza genera tracce di stat
ovunque ci sia un’azienda che siamo
lavorando con il suo ha fatto un prototipo in
uno spazio che stiamo esplorando potendo
fare alcune cose come nel profondo del
JVM per unire insieme lo stack logico
tracce che attraversano le nostre
frontiere se quel lavoro matura e
diventa utile lasceremo sicuramente il
mondo sapere a questo proposito mi piacerebbe davvero
per le piattaforme iniziare a risolvere questo
problema che è davvero il posto in cui
ha bisogno di essere risolto così come ha fatto tutto questo
guarda una volta che è stata fatta l’API osservabile
ha funzionato bene in quella facciata asincrona e
siamo stati in grado di passare dalla chiamata
modelli come il top in cui abbiamo avuto
tutto sincrono ed era tutto
la concorrenza era in realtà solo perché
i nostri dispositivi ci chiamavano molto eravamo
in grado di far crollare la quantità di
Chiamate di rete e spingere la maggior parte di quel lavoro
al lato server e farlo essere lo stesso
la gestione degli errori era uno sviluppatore corretto
la produttività, dopo che questo ostacolo di
allenarsi era buono e ci siamo trasferiti
da un’API di blocco a un’API osservabile
e tutto il traffico Netflix
il piano di controllo passa attraverso
il traffico osservabile come questo assolutamente
ogni richiesta di servizio web che alimenta
i nostri occhi ci passano attraverso questo
niente a che fare con il video reale
streaming per vedere DNS che è un intero
bestia diversa che sta solo andando a prendere
byte fuori da un CDN ma dal piano di controllo
tutti i nostri servizi Web inviano tutti
attraverso questo tipo di API c’erano
sfide da solo lungo la strada però così
uno di loro troppi thread okay
come se avessi un sistema simile
oltre 1.400 thread su una scatola di otto core
basti pensare a questo ora i benefici
di controbilanciare i contro per la base
la base di codice che stiamo bene
tuttavia è stato reso difficile
per sintonizzare la cosa in shedload che abbiamo realizzato
è molto più difficile che in realtà siamo abbastanza bravi
a questo, ma mi sembra di avere solo ottanta anni
per cento del modo lì e noi no
pensa che possiamo ottenere l’ultimo venti percento
è come questa magica arte nera da immaginare
fuori a che punto cade la scatola e
muore perché non è mai CPU al 98%
è come il 73% in alcuni giorni 62 altro
l’ 84 percento dei giorni dipende tutto
il modo in cui il vento soffia e che
i thread stanno facendo qualcosa e questo è un
la sfida di questo modello è anche davvero
facile da bloccare accidentalmente asincrono
codice e quindi, in questo esempio abbiamo
due modelli simultanei in alto a
sequenziale in basso quello acceso
il fondo farà questo passo cascata
ed era solo un errore dell’utente perché il
differenza una mappa piatta e mappa completamente
rompe tutto perché sul fondo
uno whoops e quello inferiore sono
invocando una chiamata bloccante e quindi cosa noi
in realtà abbiamo fatto qualcosa
fatto in modo che abbiamo appena eliminato tutto
il blocco delle chiamate nella nostra API in modo che noi
reso davvero difficile che tu in realtà
devi coscientemente uscire dalla tua strada
per farcela, il fatto è che c’è
non c’è una corretta modularizzazione in java
gli sviluppatori commettono errori è davvero
facile da infilare nel vecchio modello così è
basta un semplice blocco e chiamalo restituisce
T e abbiamo visto nel codice di produzione come
questo esce e tutto ad un tratto noi
distruggere le prestazioni su qualcosa e il nostro
I canarini devono trovarlo o se è un
piccola cosa non la troviamo troppo tardi
questo è un problema con mescolare le cose in
un ambiente che non è costruito per questo
così lungo il modo in cui iniziamo a chiedere o così
Che cosa succede se abbiamo fatto fare lo sforzo di andare
come fare una riscrittura verde di questo
strato e quello che ho trovato era mito e
leggenda ovunque era come vicino
impossibile ottenere risposte dirette
qualsiasi cosa e vado alle aziende che chiedono
quindi perché hai adottato qualcosa di simile
Metis o qualsiasi altra cosa e ottengo questa risposta
Sono davvero perché è meglio
che questa è una risposta come quella che è
non utile o ho capito che è peggio di non farlo
come assolutamente non farlo
distrugge completamente tutto o è
lo strumento sbagliato per il lavoro tutto questo
roba che avrei preso anche non importa
come qualsiasi cosa tu preferisca e così via
Ho ricercato sempre più e più volte
fondamentalmente trovato che tutti questi diversi
approcci per affrontare la concorrenza
teoricamente dovrebbero tutti fare il
stessa cosa per cui se si bollire il tutto a
ad un certo punto hai le stesse CPU di
stessa memoria lo stesso come fisico
risorse se tu se tutta la programmazione
e qualunque astrazione tu abbia usato
per tagliarlo e tagliarlo nello stesso modo
modo efficiente con cui le astrazioni dovrebbero
teoricamente tutto equivale al
la realtà però non è così, ma questo è
dove molta della confusione che affronto
sarebbe arrivato come per esempio c’è un
articolo sui thread utente che conosci io
non dovrebbe essere necessario utilizzare le callback perché
dei miei thread utente è giusto
l’astrazione è come quello che è morto
fantastico se il mio runtime lo avesse effettivamente dato
per me in un modo che ha funzionato, ma è così
non è l’unico accordo che ho ottenuto
da parte di chiunque lo è se ci stai provando
risolvere il problema 10k mare che è
10.000 connessioni simultanee su una scatola
e quello era un decennio fa o come adesso
è come cento K o un milione che ho
anche io conosco persone che sono decisamente
eseguendo un milione di connessioni simultanee
su una scatola in produzione oggi sono ora
iniziando ad affrontare dieci milioni che
mi sconcerta, non ho dubbi che lo faremo
arrivare lì questo è l’ unico posto che io
ho ottenuto un accordo che sì, vai all’evento
si avvicina a un I / o non bloccante per quelli
le cose sono l’unico posto dove posso arrivare
alle persone piace non discutere con me e così via
Ho avuto questo problema che mi piaceva quello che sono
Scommetto il futuro di una bella
sistema importante e Netflix su e io
non volevo che fosse basato sul mito e
leggenda o budella di Jack o opinioni o simili
sai
tutta quella roba e così abbiamo fatto tutto
cattivo ingegnere, abbiamo scritto un punto di riferimento
e disastroso, naturalmente, ma lo dirò
perché, in un secondo, perché questo è effettivamente
interessante quindi abbiamo creato questa cosa
dove ci manca c’è come il
servizio web stereotipato su Netflix
dove qualcosa entra ti mette in moto
un po ‘di lavoro e poi come quel lavoro arriva
torni a dare un po ‘di più e poi
un po ‘di più e poi lo componi tutto
insieme nel totalmente inefficiente
JSON e io usiamo espressamente JSON in questo modo
In realtà ero realista perché provavo come
Potremmo in realtà non usare un intero
molto efficiente tipo di codifica binaria
cose che sto cercando di ottenere
dei nostri sistemi lì, ma onestamente di più
di questo tipo di cose è il
realtà e non siamo una iper latenza
azienda guidata e quindi la maggior parte del tempo
è abbastanza buono e così questo
tutta la cosa dovrebbe richiedere altri 150 154
millisecondi in una perfetta esecuzione di
e la maggior parte sta solo aspettando l’I / O
molto poco è in realtà
calcolo e onestamente molto poco di
tutti i servizi che vedo stanno facendo
qualsiasi computazione diversa dalla nostra
serializzazione inefficiente e
deserializzazione di swill che inviamo
attraverso il filo e così abbiamo testato questo in
il cloud e tutto quel genere di cose ma
alla fine noi beta abbiamo fatto proprio come nude
metallo quindi possiamo averne un po ‘
dati interessanti fuori di esso e l’unico
motivo per cui ho fiducia e
la fiducia in questi numeri è perché io
ho lavorato con Brendan Gregg e
Brendan Gregg ha scritto un libro
quello spesso è come due pollici di spessore
assistente alla performance ed ero davvero
fortunato di averlo a Netflix al lavoro
con questo e ci sono voluti mesi e
mesi e mesi da ciò che ho imparato
questo è se davvero andrai e
prova a rispondere a questo tipo di domande
intenzione di perdere un sacco di tempo se siete
in realtà intenzione di andare a cercare di fare fare
benchmark e abbiamo usato solo Tomcat
niente come niente di interessante o interessante
realmente e quindi ecco la prima delle
presentazione sui dati che eravamo in realtà
in grado di spingere entrambi fino a quasi
tutto l’utilizzo della CPU ora quando siamo prima
iniziato non siamo riusciti a ottenere Tomcat da nessuna parte
vicino a quello che in realtà abbiamo dovuto spendere due
settimane semplicemente sintonizzando Tomcat per essere in grado di
max out the box che è il primo segno
in realtà piace a Neddie
non avevamo configurato niente , ma funziona
che in realtà è un buon segno, ma Tomcat
siamo stati in grado di ottenerli entrambi
punto qui è dove inizia a prendere
Interessante Nettie ha una CPU inferiore
consumo per richiesta e mantiene
sempre più veloce sotto carico spiegherò
che in un po ‘così perché così
Nettie raggiunge sicuramente più in alto
throughput notevolmente e siamo stati in grado
per dimostrare che questo è principalmente perché
di minor consumo di CPU per richiesta noi
sono stati in grado di tenere traccia di ciò in tutto il
metriche stavamo usando grafici di fiamma e
statistiche e cose diverse nella media
latenza ora latenza media fa schifo è
totalmente inutile non usarlo è solo
interessante su questo grafico per vedere anche
come la media risolve la media
la latenza qui per Nettie è migliore di
Tomcat ma questo è dove arriva
interessante che inizi a guardare al massimo
latenza e sono come il 99 9 e
99 ° 90 ecc., Quindi non solo abbiamo
così tanto tempo oggi, quindi non posso mostrarvi
tutte quelle cose, ma quando inizi
entrambi sono effettivamente in linea
e ciò che la cosa interessante qui è
in realtà inizia a confermare il
premettiamo che teoricamente questi due
dovrebbe comportarsi e ottenere la stessa cosa
e quando il sistema non è sotto carico
in realtà tiene fuori tutti e due
efficacemente comportato lo stesso per quanto riguarda
l’utente prova la latenza su di loro quando
il sistema non è sotto carico durante la rampa
il Tomcat cade e così via
diamo un’occhiata a cosa sta succedendo
istruzioni reali per ciclo per Nettie
che è un evento del modello di ciclo un evento
loop procore in realtà ottiene di più
efficiente come hai messo sotto carico questo era
affascinante per guardare Nettie diventa più veloce
mentre lo spingi più forte, ok
migrazioni thread è stato davvero dove
ha iniziato a mostrare cosa stava succedendo e
così all’inizio abbiamo scelto di non appuntare
discussioni o qualcosa del genere
questo non è il mondo in cui viviamo
lo stiamo esplorando ma non lo ottimizziamo
a quel livello quindi lasciamo il funzionamento
sistema solo pianificare le cose e quando
è sotto carico leggero ogni volta un evento
Era il ciclo o il thread per richiesta
invocato stava ancora programmando
roba e così entrambi stavano migrando
discussioni e sempre bene quando si inizia
per essere sotto carico attraverso il ciclo degli eventi
iniziano a scaldarsi e in realtà iniziano
fare la cosa giusta
e basta iniziare a tubare tutto
e quindi è pensato allo schedulatore
smesso di migrare smesso di spostarli
intorno a dove è il modello Tomcat è tutto
ogni volta che fa un evento richiesto
pianificare un thread che preleva un core mette
su di esso e così le migrazioni dei thread
diventa una cosa importante con Tomcat, quindi perché
Tomcat era più veloce e più efficiente e
perché ha scalato meglio tutte quelle cose
il primo appena codice migliore di Nettie
di Tomcat come se potessimo effettivamente vedere
nel nostro profilo che era molto meglio
ottimizzato per l’assegnazione di oggetti e
quei tipi di cose che ho appena più piccolo
pile hanno fatto di tutto per non farlo
allocare memoria quei tipi di cose
l’architettura del ciclo degli eventi anche se noi
sono stati in grado di dimostrare effettivamente fatto
impatto sulle migrazioni di thread ridotte
che a sua volta influenza il calore della cache
istruzioni sulla memoria per ciclo
e alla fine la cosa che eravamo
in grado di tracciare sin dall’inizio più in basso
Consumo di CPU per ciclo e poi noi
sono stati in grado di individuare nel thread poveri
architettura quantità non trascurabili di tempo
che sono stati spesi per contesa della serratura e
migrazioni di thread
ci sono molti più dati dietro questo
di quanto Brendan Greg potesse parlare di questo
molto più interessante di me cosa noi
sono stati in grado di determinare da esso però è
che nonostante tutte le teorie con
attuali implementazioni JVM e Linux
c’è un vantaggio per noi per adottare il
event loop architecture e anche noi
trovato attraverso questo tutto ciò che era
interessante per me
Ho trovato molto più semplice scrivere e
operare il modello del ciclo di eventi rispetto al
centro commerciale thread non è più facile anche se più facile
è più facile per me fare quello Tomcat
perché è lì che ho 15 anni
della storia farlo quindi devo piace
in realtà pensare di più l’evento di un
e anche i nostri strumenti di succhiare a trattare con
che come noi non abbiamo non abbiamo 20
anni di strumenti attorno agli eventi in
Infatti ho scoperto che ha funzionato tipo
esattamente allo stesso modo della latenza
curva è lo sforzo per ottenere Tomcat
andando è piuttosto accomodante e poi
quando hai effettivamente provato a ridimensionare il
cosa e si sintonizza bene e mi piace come
ha gettato il carico di tutta quella roba perché il
la difficoltà è esattamente come la sua
curva di latenza quindi abbiamo trovato che completamente
l’architettura asincrona ha dei vantaggi
abbastanza sufficiente da iniziare
uno sforzo enorme per andare e
riscrivi il nostro front-end
e migrare fuori dal centro commerciale tommcatt
oltre a Eddy e la cosa interessante
era in realtà non era il the
guadagni di throughput che alla fine hanno guidato
in questo modo potremmo investire denaro
risolvendo possiamo scalare orizzontalmente per noi
il motivo che ci ha spinto è stato il
vantaggi operativi il fatto che io possa
spingere quella cosa fino al 98 99% e
ancora fidati di come sarebbe andata la mia macchina
eseguire la disponibilità e l’esperienza dell’utente
i benefici sono molto più importanti per noi
di quanto possiamo solo buttare soldi alle macchine
è più economico degli ingegneri
questo, ma la disponibilità e le operazioni sono
una programmazione così reattiva può essere
applicato in modo incrementale ma viene
con le sfide quando si mescolano
basi di codice
concorrenza da un servizio di sincronizzazione
la composizione è stata nel nostro ambiente
su vasta scala per molti anni di gestione di questo
con dozzine di ingegneri di vario tipo
livelli di esperienza con esso ha funzionato
davvero bene per noi siamo molto contenti
questo rx Java orari e thread possono
essere sfruttato per colmare tale lacuna in
realtà anche se usiamo solo distretti
per questo motivo la storia è colpa nostra
il nostro livello di gestione dei guasti è fondamentalmente
fa intestazione di massa e tutto quel tipo di
roba in realtà ne facciamo uso
tutta quella roba che ci avvolge bloccando
I / O si occupa con esso aggiunge il
thread e simultaneità e intestazione
e metriche e tutte queste cose così noi
in realtà non fare nulla di tutto ciò direttamente
codice che ti ho mostrato prima così noi
basta mettere tutto in uno strato in
isterici piuttosto che ovunque nel nostro
codice ripetendo la stessa cosa sopra e
di nuovo in chiusura concorrenza è
comunque è ok non banale che non lo è
andare via la nostra X non prova e
banalizzare ogni tentativo che abbia mai fatto
visto per astrarre completamente quella roba
di distanza e rendono banale e facile ottiene
circa l’80% del modo in cui ci sei e poi tu
devo perforare il lato ad un certo punto
e rompere completamente il sistema e io
ho scoperto che finora non ho visto
una soluzione là fuori che risolve
concorrenza e asincronia in un modo
puoi ignorare completamente ciò che sta succedendo
su sono astrazioni che perdi hai
per capire ancora cosa sta succedendo
Rx è una libreria non un framework così tu
applicalo dove è necessario non lo fa
prendi il tuo ecosistema e
è stato importante per noi non lo siamo
lì non me lo aspetto mai
vedere una cella per un sistema del genere ma io
credo che siamo in procinto di
per lo meno essere oh forse tira quei piccoli
astronavi lassù e come portarle
a New York ora forse sembro
Vendicatori e c’è molto di più
le informazioni qui sono finite ed è
più di tutto di cui ho parlato è tutto
open source e prenderò domande se
avete
tu
Please follow and like us: