Saya ingin memberi tahu Anda tentang disiplin pemrograman modern yang memenuhi tuntutan yang terus meningkat akan skalabilitas, toleransi kesalahan, dan respons cepat, dan sangat diperlukan di lingkungan multi-core dan di komputasi awan, serta menyajikan kursus online terbuka tentangnya, yang akan dimulai hanya dalam beberapa hari.
Jika Anda belum pernah mendengar tentang pemrograman reaktif, Semuanya baik-baik saja. Ini adalah disiplin yang berkembang pesat yang menggabungkan konkurensi dengan event-driven dan asinkron. Reaktivitas melekat dalam layanan web dan sistem terdistribusi apa pun, dan merupakan inti dari banyak sistem berkinerja tinggi dengan tingkat paralelisme yang tinggi. Singkatnya, penulis kursus mengusulkan untuk mempertimbangkan pemrograman reaktif sebagai perpanjangan alami dari pemrograman fungsional (dengan fungsi tingkat tinggi) ke sistem paralel dengan keadaan terdistribusi, dikoordinasikan dan diatur oleh aliran data asinkron yang dipertukarkan oleh subjek aktif, atau aktor.
Dengan kata-kata yang lebih mudah dipahami, ini dijelaskan dalam Reactive Manifesto, di bawah ini saya akan menceritakan kembali ketentuan utama darinya, dan terjemahan lengkapnya diterbitkan di Habré. Seperti kata Wikipedia, istilahnya pemrograman reaktif sudah ada sejak lama dan aplikasi praktis berbagai tingkat eksotisme, tetapi menerima dorongan baru untuk pengembangan dan distribusi baru-baru ini, berkat upaya penulis Reactive Manifesto, sebuah kelompok inisiatif dari Typesafe Inc. Typesafe dikenal di komunitas pemrograman fungsional sebagai perusahaan yang didirikan oleh penulis bahasa Scala yang luar biasa dan platform paralel revolusioner Akka. Sekarang mereka memposisikan perusahaan mereka sebagai pencipta platform jet pertama di dunia yang dirancang untuk mengembangkan generasi baru. Platform mereka memungkinkan Anda untuk mengembangkan kompleks dengan cepat antarmuka pengguna dan memberikan tingkat abstraksi baru melalui komputasi paralel dan multithreading, mengurangi risiko bawaannya melalui penskalaan yang dijamin dapat diprediksi. Ini mempraktikkan ide-ide Manifesto Reaktif dan memungkinkan pengembang untuk memahami dan membuat aplikasi yang memenuhi tuntutan modern.
Anda dapat mengenal platform ini dan pemrograman reaktif dengan mengikuti Kursus Daring Terbuka Masif Prinsip Reaktif. Kursus ini merupakan kelanjutan dari kursus "Principles of Functional Programming in Scala" dari Martin Odersky, yang telah diikuti oleh lebih dari 100.000 peserta dan menunjukkan salah satu tingkat keberhasilan tertinggi untuk Kursus Daring Terbuka Masif oleh para pesertanya di dunia. Bersama pencipta bahasa Scala, kursus baru ini diajarkan oleh Eric Meyer, yang mengembangkan kerangka kerja Rx untuk pemrograman reaktif di bawah .NET, dan Roland Kuhn, yang saat ini memimpin tim pengembangan Akka di Typesafe. Kursus ini mencakup elemen kunci dari pemrograman reaktif dan menunjukkan bagaimana penerapannya untuk merancang sistem berbasis kejadian yang dapat diskalakan dan toleran terhadap kesalahan. Bahan ajar diilustrasikan program singkat dan disertai dengan serangkaian tugas, yang masing-masing merupakan proyek perangkat lunak. Jika berhasil menyelesaikan semua tugas, peserta menerima sertifikat (tentu saja, partisipasi dan sertifikat gratis). Kursus berlangsung 7 minggu dan dimulai Senin ini, 4 November. Garis besar terperinci serta video pengantar tersedia di halaman kursus: https://www.coursera.org/course/reactive.
Bagi mereka yang tertarik atau ragu, saya menawarkan ringkasan singkat tentang konsep dasar Manifesto Reaktif. Penulisnya mencatat perubahan signifikan dalam persyaratan aplikasi untuk tahun-tahun terakhir. Aplikasi hari ini dikerahkan di lingkungan apa pun dari perangkat seluler ke cluster cloud dengan ribuan prosesor multi-core. Lingkungan ini menempatkan tuntutan baru perangkat lunak dan teknologi. Arsitektur generasi sebelumnya berfokus pada server dan wadah terkelola, penskalaan melalui perangkat keras tambahan yang mahal, solusi berpemilik, dan komputasi paralel melalui multithreading. Sebuah arsitektur baru sedang dikembangkan yang memiliki empat fitur utama yang semakin lazim di lingkungan industri konsumen dan perusahaan. Sistem dengan arsitektur ini bersifat: event-driven, scalable, fault-tolerant (Resilient) dan memiliki respon yang cepat, yaitu. responsif (Responsif). Hal ini memberikan pengalaman pengguna yang lancar dan real-time yang didukung oleh tumpukan aplikasi yang dapat menyembuhkan sendiri dan dapat diskalakan yang siap diterapkan di lingkungan multi-core dan cloud. Masing-masing dari empat karakteristik arsitektur reaktif berlaku untuk seluruh tumpukan teknologi, yang membedakannya dari tautan dalam arsitektur berlapis. Mari kita pertimbangkan lebih detail.
Didorong oleh Peristiwa aplikasi mengasumsikan komunikasi komponen asinkron dan mengimplementasikan desainnya yang digabungkan secara longgar: pengirim dan penerima pesan tidak perlu mengetahui satu sama lain atau tentang metode pengiriman pesan, yang memungkinkan mereka untuk berkonsentrasi pada konten komunikasi. Selain fakta bahwa komponen yang digabungkan secara longgar secara signifikan meningkatkan pemeliharaan, ekstensibilitas, dan evolusi sistem, sifat asinkron dan non-pemblokiran dari interaksinya juga dapat membebaskan sebagian besar sumber daya, mengurangi waktu respons, dan menyediakan HAI lagi throughput dibandingkan dengan aplikasi tradisional. Berkat sifat yang digerakkan oleh peristiwa, fitur arsitektur reaktif lainnya dimungkinkan.
Skalabilitas dalam konteks pemrograman reaktif, ini adalah reaksi sistem terhadap perubahan beban, mis. elastisitas, dicapai dengan kemampuan untuk menambah atau melepaskan node komputasi sesuai kebutuhan. Dengan sambungan rendah, perpesanan asinkron, dan transparansi lokasi, metode penerapan dan topologi aplikasi menjadi keputusan waktu penerapan dan tunduk pada konfigurasi responsif beban dan algoritme adaptif. Dengan demikian, jaringan komputer menjadi bagian dari aplikasi, awalnya memiliki sifat terdistribusi eksplisit.
toleransi kesalahan arsitektur reaktif juga menjadi bagian dari desain, dan ini membuatnya sangat berbeda dari pendekatan tradisional untuk memastikan ketersediaan sistem yang berkelanjutan melalui redundansi dan kegagalan server. Ketahanan sistem seperti itu dicapai dengan kemampuannya untuk menanggapi kegagalan komponen individu dengan benar, mengisolasi kegagalan ini dengan menyimpan konteksnya dalam bentuk pesan yang menyebabkannya, dan meneruskan pesan ini ke komponen lain yang dapat membuat keputusan tentang bagaimana caranya. menangani kesalahan. Pendekatan ini memungkinkan Anda untuk menjaga logika bisnis aplikasi tetap bersih, memisahkan logika penanganan kegagalan darinya, yang dirumuskan dalam bentuk deklaratif eksplisit untuk mendaftarkan, mengisolasi, dan menangani kegagalan melalui sistem itu sendiri. Untuk membangun sistem penyembuhan diri seperti itu, komponen disusun secara hierarkis, dan masalahnya dinaikkan ke tingkat yang dapat menyelesaikannya.
Dan akhirnya daya tanggap- ini adalah kemampuan sistem untuk merespons masukan pengguna terlepas dari beban dan kegagalan, aplikasi semacam itu melibatkan pengguna dalam interaksi, menciptakan perasaan koneksi dekat dengan sistem dan peralatan yang memadai untuk melakukan tugas saat ini. Daya tanggap relevan tidak hanya dalam sistem real-time, tetapi juga diperlukan untuk berbagai aplikasi. Selain itu, sistem yang tidak dapat merespons dengan cepat bahkan pada saat terjadi kegagalan tidak dapat dianggap toleran terhadap kesalahan. Daya tanggap dicapai dengan menggunakan model yang dapat diamati, aliran peristiwa, dan klien yang stateful. Model yang dapat diamati memancarkan peristiwa ketika statusnya berubah dan menyediakan interaksi waktu nyata antara pengguna dan sistem, sementara aliran peristiwa menyediakan abstraksi di mana interaksi ini dibangun melalui transformasi dan komunikasi asinkron non-pemblokiran.
Dengan demikian, aplikasi reaktif merupakan pendekatan yang seimbang untuk memecahkan berbagai masalah pengembangan perangkat lunak modern. Dibangun di atas fondasi yang digerakkan oleh peristiwa, mereka menyediakan alat yang diperlukan untuk menjamin skalabilitas dan toleransi kesalahan, dan mendukung pengalaman pengguna yang responsif dengan fitur lengkap. Penulis mengharapkan itu semua lagi sistem akan mematuhi prinsip-prinsip manifesto reaktif.
Selain itu, saya memberikan rencana kursus tanpa terjemahan. Kalau-kalau Anda sudah membaca sejauh ini dan masih penasaran.
Minggu 1: Tinjauan Prinsip Pemrograman Fungsional: model substitusi, ekspresi-for dan bagaimana hubungannya dengan monad. Memperkenalkan implementasi baru untuk ekspresi: generator nilai acak. Menunjukkan bagaimana ini dapat digunakan dalam pengujian acak dan memberikan ikhtisar tentang ScalaCheck, alat yang mengimplementasikan ide ini.
Minggu 2: Pemrograman fungsional dan status yang dapat diubah. Apa yang membuat objek bisa berubah? Bagaimana ini berdampak pada model substitusi. Contoh yang diperluas: Simulasi rangkaian digital
Minggu 3: masa depan. Memperkenalkan masa depan sebagai monad lain, dengan ekspresi-untuk sebagai sintaks konkret. Menunjukkan bagaimana masa depan dapat disusun untuk menghindari pemblokiran utas. Membahas penanganan kesalahan lintas-utas.
Minggu 4: Pemrosesan aliran reaktif. Generalisasi masa depan untuk perhitungan reaktif melalui aliran. operator aliran.
Minggu 5: Aktor. Memperkenalkan Model Aktor, aktor sebagai unit konsistensi yang dienkapsulasi, pengiriman pesan asinkron, membahas semantik pengiriman pesan yang berbeda (paling banyak sekali, setidaknya sekali, tepat sekali) dan konsistensi akhirnya.
Minggu 6: pengawasan. Memperkenalkan reifikasi kegagalan, penanganan kegagalan hierarkis, pola Error Kernel, pemantauan siklus hidup, membahas status transien dan persisten.
Minggu 7: Pola Percakapan. Membahas manajemen keadaan percakapan antara aktor dan pola untuk kontrol aliran, merutekan pesan ke kumpulan aktor untuk ketahanan atau penyeimbangan muatan, pengakuan penerimaan untuk mencapai pengiriman yang andal.
Dunia pengembangan OOP pada umumnya dan bahasa Jawa pada khususnya menjalani kehidupan yang sangat aktif. Ini memiliki tren fesyennya sendiri, dan hari ini kami akan menganalisis salah satu tren utama musim ini - kerangka kerja ReactiveX. Jika Anda masih menyendiri dari gelombang ini - saya jamin Anda akan menyukainya! Ini pasti lebih baik daripada jeans berpinggang tinggi :).
Pemrograman reaktif
Segera setelah bahasa OOP matang untuk digunakan secara massal, pengembang menyadari betapa kemampuan bahasa mirip-C terkadang kurang. Karena menulis kode dengan gaya pemrograman fungsional secara serius merusak kualitas kode OOP, dan karenanya pemeliharaan proyek, sebuah hibrida ditemukan - pemrograman reaktif.
Paradigma pengembangan reaktif didasarkan pada gagasan untuk terus melacak perubahan keadaan suatu objek. Jika perubahan seperti itu telah terjadi, maka semua objek yang tertarik harus menerima data yang sudah diperbarui dan hanya bekerja dengannya, melupakan yang lama.
Contoh bagus dari ide pemrograman reaktif adalah spreadsheet Excel. Jika Anda menautkan beberapa sel dengan satu rumus, hasil penghitungan akan berubah setiap kali data dalam sel tersebut berubah. Untuk akuntansi, perubahan data yang dinamis seperti itu adalah hal yang umum, tetapi bagi pemrogram ini merupakan pengecualian.
A=3; b=4; c=a+b; F1(c); a=1; F2(c);
Dalam contoh ini, fungsi F1 dan F2 akan bekerja dengan nilai yang berbeda dari variabel C. Seringkali kedua fungsi tersebut hanya membutuhkan data terbaru - pemrograman reaktif akan memungkinkan Anda untuk segera memanggil F1 dengan yang baru parameter tanpa mengubah logika fungsi itu sendiri. Struktur kode ini memberi aplikasi kemampuan untuk merespons perubahan apa pun secara instan, yang akan membuatnya cepat, fleksibel, dan responsif.
ReaktifX
Menerapkan ide-ide pemrograman reaktif dari awal bisa sangat merepotkan - ada jebakan, dan itu akan memakan waktu yang cukup lama. Oleh karena itu, bagi banyak pengembang, paradigma ini hanya menjadi bahan teoretis hingga ReactiveX muncul.
Kerangka kerja ReactiveX adalah alat pemrograman reaktif yang bekerja dengan semua bahasa OOP populer. Pembuatnya sendiri menyebutnya API multi-platform untuk pengembangan asinkron, berdasarkan pola Pengamat.
Jika istilah "pemrograman reaktif" adalah sejenis model teoretis, maka pola Pengamat adalah mekanisme siap pakai untuk melacak perubahan dalam suatu program. Dan Anda harus cukup sering melacaknya: memuat dan memperbarui data, pemberitahuan acara, dan sebagainya.
Pola Pengamat telah ada selama OOP itu sendiri. Objek yang statusnya dapat berubah disebut penerbit (terjemahan populer dari istilah Observable). Semua peserta lain yang tertarik dengan perubahan ini adalah pelanggan (Pengamat, Pelanggan). Untuk menerima notifikasi, pelanggan mendaftar ke penerbit dengan secara eksplisit menentukan ID mereka. Penerbit dari waktu ke waktu menghasilkan notifikasi, yang dikirim oleh penerbit ke daftar pelanggan terdaftar.
Sebenarnya, pembuat ReactiveX tidak menghasilkan sesuatu yang revolusioner, mereka hanya menerapkan polanya dengan nyaman. Dan meskipun banyak bahasa OOP, dan khususnya Java, memiliki implementasi pola yang sudah jadi, kerangka kerja ini memiliki "penyetelan" tambahan yang mengubah "Pengamat" menjadi alat yang sangat kuat.
RxAndroid
Porta perpustakaan ReactiveX untuk dunia Android disebut rxAndroid dan terhubung, seperti biasa, melalui Gradle.
Kompilasi "io.reactivex:rxandroid:1.1.0"
Penerbit yang menghasilkan notifikasi ditentukan di sini menggunakan kelas Observable. Penerbit dapat memiliki beberapa pelanggan, untuk mengimplementasikannya, kami akan menggunakan kelas Pelanggan. Perilaku default untuk Observable adalah mengeluarkan satu atau beberapa pesan ke pelanggan dan kemudian keluar atau mengeluarkan pesan kesalahan. Pesan dapat berupa variabel dan objek bilangan bulat.
Rx.Observable myObserv = rx.Observable.create(baru rx.Observable.OnSubscribe
Dalam hal ini, penerbit myObserv pertama-tama akan mengirimkan string halo dan pesan, lalu pesan sukses. Penayang dapat memanggil metode onNext() , onCompleted() , dan onEror() , sehingga pelanggan harus menentukannya.
Pelanggan mySub = Pelanggan baru
Semuanya siap untuk bekerja. Tetap menghubungkan objek satu sama lain - dan "Halo, dunia!" dalam pemrograman reaktif sudah siap!
MyObserv.subscribe(mySub);
Saya harus mengatakan bahwa ini adalah contoh yang sangat sederhana. ReactiveX memiliki banyak opsi untuk perilaku semua peserta dalam pola: pemfilteran, pengelompokan, penanganan kesalahan. Manfaat pemrograman reaktif hanya bisa dirasakan dengan mencobanya dalam tindakan. Mari kita mulai tugas dengan lebih serius.
Terus tersedia untuk anggota saja
Opsi 1. Bergabunglah dengan komunitas "situs" untuk membaca semua materi di situs
Keanggotaan dalam komunitas selama periode yang ditentukan akan memberi Anda akses ke SEMUA materi Peretas, meningkatkan diskon kumulatif pribadi Anda, dan memungkinkan Anda mengumpulkan peringkat Skor Xakep profesional!
Pergi.
Pemrograman reaktif pada awalnya terdengar seperti nama paradigma yang baru lahir, tetapi sebenarnya mengacu pada metode pemrograman yang menggunakan pendekatan berbasis peristiwa untuk bekerja dengan aliran data asinkron. Berdasarkan data yang terus-menerus terkini, sistem reaktif bereaksi terhadapnya dengan menjalankan serangkaian peristiwa.
Pemrograman reaktif mengikuti pola desain Pengamat, yang dapat didefinisikan sebagai berikut: jika perubahan status terjadi pada satu objek, maka semua objek lainnya akan diberi tahu dan diperbarui sesuai dengan itu. Jadi, alih-alih polling peristiwa untuk perubahan, peristiwa didorong secara asinkron sehingga pengamat dapat memprosesnya. Dalam contoh ini, pengamat adalah fungsi yang dijalankan saat suatu peristiwa dikirim. Dan aliran data yang disebutkan adalah yang sebenarnya dapat diamati.
Hampir semua bahasa dan kerangka kerja menggunakan pendekatan ini dalam ekosistemnya, dan versi terbaru Java tidak terkecuali. Pada artikel ini, saya akan menjelaskan bagaimana pemrograman reaktif dapat diterapkan menggunakan JAX-RS versi terbaru di fungsionalitas Java EE 8 dan Java 8.
Manifesto Reaktif
Manifesto Reaktif mencantumkan empat aspek mendasar yang diperlukan aplikasi agar lebih fleksibel, digabungkan secara longgar, dan mudah untuk diskalakan, dan karenanya dapat menjadi reaktif. Dikatakan bahwa aplikasi harus responsif, fleksibel (dan karenanya dapat diskalakan), tangguh, dan digerakkan oleh pesan.
Tujuan yang mendasarinya adalah aplikasi yang benar-benar responsif. Katakanlah Anda memiliki aplikasi yang memiliki satu utas besar yang memproses permintaan pengguna, dan saat pekerjaan selesai, utas tersebut mengirimkan respons kembali ke pemohon asli. Saat aplikasi menerima lebih banyak permintaan daripada yang dapat ditanganinya, alur ini menjadi hambatan dan aplikasi kehilangan daya tanggap sebelumnya. Agar tetap responsif, aplikasi harus dapat diskalakan dan tangguh. Aplikasi tangguh adalah aplikasi yang memiliki fungsi pemulihan otomatis. Dalam pengalaman sebagian besar pengembang, hanya arsitektur berbasis pesan yang memungkinkan aplikasi untuk dapat diskalakan, kuat, dan responsif.
Pemrograman reaktif diperkenalkan di Java 8 dan Java EE 8. Bahasa Java memperkenalkan konsep seperti CompletionStage dan implementasi CompletableFuture, dan Java mulai menggunakan fitur ini dalam spesifikasi seperti API Klien Reaktif di JAX-RS.
JAX-RS 2.1 API Klien Reaktif
Mari kita lihat bagaimana pemrograman reaktif dapat digunakan dalam aplikasi Java EE 8. Untuk memahami prosesnya, Anda memerlukan pengetahuan dasar tentang Java EE API.
JAX-RS 2.1 memperkenalkan cara baru untuk membuat klien REST reaktif. Implementasi default dari invoker yang ditawarkan oleh JAX-RS adalah sinkron, yang berarti bahwa klien yang sedang dibuat akan mengirimkan panggilan pemblokiran ke titik akhir server. Contoh implementasi disediakan di Listing 1.
Tanggapan tanggapan = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .get();
Dimulai dengan versi 2.0, JAX-RS menyediakan dukungan untuk membuat invoker asinkron pada API klien dengan panggilan sederhana ke metode async(), seperti yang ditunjukkan pada Listing 2.
Masa depan
Menggunakan invoker asinkron pada klien mengembalikan instance Future dari tipe javax.ws.rs.core.Response . Hal ini dapat menghasilkan polling untuk respons, memanggil future.get() , atau mendaftarkan callback yang akan dipanggil saat ada respons HTTP yang tersedia. Kedua implementasi cocok untuk pemrograman asinkron, tetapi hal-hal cenderung menjadi lebih rumit jika Anda ingin mengelompokkan panggilan balik atau menambahkan kasus bersyarat ke minima eksekusi asinkron tersebut.
JAX-RS 2.1 menyediakan cara reaktif untuk mengatasi masalah ini dengan API Klien Reaktif JAX-RS baru untuk rakitan klien. Sesederhana memanggil metode rx() selama pembuatan klien. Di Listing 3, metode rx() mengembalikan invoker reaktif yang ada selama eksekusi klien, dan klien mengembalikan respons dengan tipe CompletionStage.rx() , yang memungkinkan transisi dari invoker sinkron ke invoker asinkron dengan sederhana panggilan.
Tahap Penyelesaian
Tahap Penyelesaian<Т>adalah antarmuka baru yang diperkenalkan di Java 8. Ini merupakan perhitungan, yang bisa menjadi langkah dalam perhitungan yang lebih besar, seperti namanya. Ini adalah satu-satunya reaktivitas Java 8 yang membuatnya menjadi JAX-RS.
Setelah menerima instance respons, saya dapat memanggil AcceptAsync() , di mana saya dapat memberikan potongan kode yang akan dieksekusi secara asinkron saat respons tersedia, seperti yang ditunjukkan pada Listing 4.
Response.thenAcceptAsync(res -> ( Temperature t = res.readEntity(Temperature.class); //lakukan sesuatu dengan t ));
Menambahkan reaktivitas ke titik akhir REST
Pendekatan reaktif tidak terbatas pada sisi klien di JAX-RS; itu dapat digunakan di sisi server juga. Sebagai contoh, pertama-tama saya akan membuat skrip sederhana tempat saya dapat meminta daftar lokasi untuk satu tujuan. Untuk setiap posisi, saya akan melakukan panggilan terpisah dengan data lokasi ke titik lain untuk mendapatkan nilai suhu. Interaksi tujuan akan seperti yang ditunjukkan pada Gambar 1.
Gambar 1. Interaksi antar destinasi
Pertama saya hanya menentukan model domain dan kemudian layanan untuk setiap model. Daftar 5 menunjukkan bagaimana kelas Prakiraan didefinisikan, yang membungkus kelas Lokasi dan Suhu.
Kelas publik Suhu ( suhu Ganda pribadi; skala String pribadi; // getter & setter ) Lokasi kelas publik ( Nama string; Lokasi publik() () Lokasi publik(Nama string) ( this.name = nama; ) // getter & setter ) Prakiraan kelas publik ( lokasi Lokasi pribadi; Suhu suhu pribadi; Prakiraan publik(Lokasi lokasi) ( this.location = lokasi; ) Prakiraan publik setTemperature(Suhu akhir suhu) ( this.temperature = suhu; kembalikan ini; ) // getter )
Untuk membungkus daftar prediksi, kelas ServiceResponse diimplementasikan di Listing 6.
ServiceResponse kelas publik (waktu pemrosesan panjang pribadi; Daftar pribadi
LocationResource , ditunjukkan pada Listing 7, mendefinisikan tiga pola lokasi yang dikembalikan dengan path /location .
@Path("/location") kelas publik LocationResource ( @GET @Produces(MediaType.APPLICATION_JSON) respons publik getLocations() ( Daftar
TemperatureResource , ditampilkan di Listing 8, mengembalikan nilai suhu yang dihasilkan secara acak antara 30 dan 50 untuk lokasi tertentu. Penundaan 500ms telah ditambahkan ke implementasi untuk mensimulasikan pembacaan sensor.
@Path("/temperature") kelas publik TemperatureResource ( @GET @Path("/(city)") @Produces(MediaType.APPLICATION_JSON) Public Response getAverageTemperature(@PathParam("city") String cityName) ( Suhu suhu = baru Temperature(); temperature.setTemperature((double) (new Random().nextInt(20) + 30)); temperature.setScale("Celsius"); try ( Thread.sleep(500); ) catch (InterruptedException diabaikan) ( diabaikan.printStackTrace(); ) mengembalikan Response.ok(temperature).build(); ) )
Pertama, saya akan menunjukkan implementasi ForecastResource sinkron (lihat Listing 9) yang mengembalikan semua lokasi. Kemudian untuk setiap posisi memanggil layanan suhu untuk mendapatkan nilai dalam derajat Celcius.
@Path("/forecast") kelas publik ForecastResource ( @Uri("location") private WebTarget locationTarget; @Uri("temperature/(city)") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public Response getLocationsWithTemperature () ( long startTime = System.currentTimeMillis(); ServiceResponse response = new ServiceResponse(); Daftar
Ketika perkiraan tujuan diminta sebagai /forecast , Anda akan mendapatkan output yang mirip dengan Listing 10. Perhatikan bahwa permintaan memerlukan waktu 1,533 md untuk diproses, yang logis karena meminta suhu dari tiga lokasi berbeda secara bersamaan menambahkan hingga 1,5 md.
( "prakiraan": [ ("lokasi": ("nama": "London" ), "suhu": ("skala": "Celcius", "suhu": 33 ) ), ("lokasi": ("nama ": "Istanbul" ), "suhu": ( "skala": "Celcius", "suhu": 38) ), ( "lokasi": ( "nama": "Praha" ), "suhu": ( "skala ": "Celsius", "temperature": 46 ) ], "processingTime": 1533 )
Sejauh ini semuanya berjalan sesuai rencana. Saatnya memperkenalkan pemrograman reaktif di sisi server, di mana panggilan ke setiap lokasi dapat dilakukan secara paralel setelah semua lokasi diterima. Ini jelas dapat meningkatkan aliran sinkron yang ditunjukkan sebelumnya. Ini dilakukan di Listing 11, yang menunjukkan definisi versi reaktif dari layanan prakiraan.
@Path("/reactiveForecast") kelas publik ForecastReactiveResource ( @Uri("location") private WebTarget locationTarget; @Uri("temperature/(city)") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public void getLocationsWithTemperature (@Suspended final AsyncResponse async) ( long startTime = System.currentTimeMillis(); // Buat stage untuk mengambil lokasi CompletionStage
Implementasi reaktif mungkin tampak rumit pada pandangan pertama, tetapi setelah melihat lebih dekat, Anda akan melihat bahwa ini cukup sederhana. Dalam implementasi ForecastReactiveResource, pertama-tama saya melakukan panggilan klien ke layanan lokasi menggunakan API Klien Reaktif JAX-RS. Seperti yang saya sebutkan di atas, ini adalah tambahan untuk Java EE 8 dan membantu membuat panggilan reaktif hanya dengan metode rx().
Sekarang saya sedang membuat tahap baru berdasarkan lokasi untuk mengumpulkan daftar prediksi. Mereka akan disimpan sebagai daftar prakiraan dalam satu tahap penyelesaian besar yang disebut forecastCS . Pada akhirnya, saya akan membuat respons panggilan layanan hanya menggunakan forecastCS .
Sekarang mari kumpulkan perkiraan sebagai daftar tahapan penyelesaian yang ditentukan dalam variabel forecastList . Untuk membuat tahap penyelesaian untuk setiap prakiraan, saya mengirimkan data lokasi dan kemudian membuat variabel tempCS, sekali lagi menggunakan API Klien Reaktif JAX-RS, yang memanggil layanan suhu dengan nama kota. Di sini, saya menggunakan metode resolveTemplate() untuk membangun klien, dan ini memungkinkan saya meneruskan nama kota ke pembangun sebagai parameter.
Sebagai langkah terakhir streaming, saya memanggil CompletableFuture.completedFuture() , meneruskan instance Forecast baru sebagai parameter. Saya menggabungkan masa depan ini dengan tahap tempCS sehingga saya memiliki nilai suhu untuk lokasi yang diulang.
Metode CompletableFuture.allOf() di Listing 11 mengubah daftar tahapan penyelesaian menjadi forecastCS . Menjalankan langkah ini mengembalikan masa depan besar yang dapat diselesaikan ketika semua masa depan yang dapat diselesaikan yang disediakan telah selesai.
Respons layanan adalah turunan dari kelas ServiceResponse, jadi saya membuat masa depan yang lengkap dan kemudian menggabungkan tahap penyelesaian forecastCS dengan daftar perkiraan dan menghitung waktu respons layanan.
Tentu saja, pemrograman reaktif hanya memaksa sisi server untuk mengeksekusi secara asinkron; sisi klien akan memblokir sampai server mengirimkan tanggapan kembali ke pemohon. Untuk mengatasi masalah ini, Server Sent Events (SSEs) dapat digunakan untuk mengirimkan respons parsial segera setelah tersedia, sehingga nilai suhu untuk setiap lokasi dikirim ke klien satu per satu. Output dari ForecastReactiveResource akan mirip dengan Listing 12. Seperti yang ditunjukkan pada output, waktu pemrosesan adalah 515ms, yang merupakan waktu eksekusi ideal untuk mendapatkan nilai suhu dari satu lokasi.
( "prakiraan": [ ("lokasi": ("nama": "London" ), "suhu": ("skala": "Celcius", "suhu": 49 ) ), ("lokasi": ("nama ": "Istanbul" ), "suhu": ( "skala": "Celcius", "suhu": 32 ) ), ( "lokasi": ( "nama": "Praha" ), "suhu": ( "skala ": "Celsius", "temperature": 45 ) ], "processingTime": 515 )
Kesimpulan
Dalam contoh di artikel ini, saya pertama kali menunjukkan cara sinkron untuk mendapatkan prakiraan menggunakan layanan lokasi dan suhu. Kemudian, saya beralih ke pendekatan reaktif agar pemrosesan asinkron dilakukan di antara panggilan layanan. Saat Anda menggunakan API Klien Reaktif JAX-RS di Java EE 8 bersama dengan kelas CompletionStage dan CompletableFuture yang tersedia di Java 8, kekuatan pemrosesan asinkron dilepaskan melalui pemrograman reaktif.
Pemrograman reaktif lebih dari sekadar mengimplementasikan model asinkron dari model sinkron; itu juga menyederhanakan konsep seperti tahap bersarang. Semakin banyak digunakan, semakin mudah mengelola skenario kompleks dalam pemrograman paralel.
Terima kasih atas perhatian Anda. Seperti biasa, kami menyambut komentar dan pertanyaan Anda.
Anda dapat membantu dan mentransfer sejumlah dana untuk pengembangan situs
Periksa informasi. Penting untuk memeriksa keakuratan fakta dan keandalan informasi yang disajikan dalam artikel ini. Seharusnya ada penjelasan di halaman pembicaraan ... Wikipedia
Interaktivitas adalah konsep yang mengungkapkan sifat dan tingkat interaksi antar objek. Digunakan di berbagai bidang: teori informasi, ilmu komputer dan pemrograman, sistem telekomunikasi, sosiologi, desain industri dan lain-lain. Di ... ... Wikipedia
Artikel ini harus di-wikifikasi. Silahkan format sesuai aturan format artikel. Istilah ini memiliki arti lain, lihat Electromash (makna) ... Wikipedia
teknik psikoterapi asing- TEKNIK DALAM Psikoterapi aktif (Fromm Reichmann). Analisis keberadaan (Binswanger). Analisis nasib (Sondi). Analisis karakter (W. Reich). Analisis I (H. Kohut, E. Erickson). Terapi permainan analitik (M. Klein). Terapi Analitik Keluarga (Richter).… … Ensiklopedia Psikologi Hebat
Buku
- Pemrograman reaktif dalam C++. Merancang Aplikasi Paralel dan Asinkron, Pai Praseed, Abraham Peter. Merancang aplikasi paralel dan asinkron menggunakan library RxCpp dan C++ modern 17 Alat pemrograman paralel yang didukung Kolaborasi…
- , Nurkevich T., Christensen B.. Saat ini, ketika program tidak sinkron, dan respons cepat adalah properti terpenting, pemrograman reaktif akan membantu menulis kode yang lebih andal, lebih terukur, dan lebih cepat.…
- Pemrograman Reaktif dengan RxJava, Tomas Nurkevich, Ben Christensen. Saat ini, ketika program tidak sinkron dan respons cepat adalah properti terpenting, pemrograman reaktif akan membantu Anda menulis kode yang lebih andal, lebih terukur, dan lebih cepat.…
Prinsip-prinsip pemrograman reaktif bukanlah hal baru dan dapat ditelusuri kembali ke karya mani Jim Gray dan Pat Helland pada sistem tandem di tahun 70-an dan 80-an.
Orang-orang ini jauh di depan waktu mereka. Hanya dalam 5-10 tahun terakhir industri teknologi dipaksa untuk merevisi "praktik terbaik" yang ada untuk pengembangan sistem perusahaan. Dia telah belajar untuk menerapkan pengetahuan tentang prinsip-prinsip reaktif dunia komputasi multi-core dan cloud saat ini.
Dasar untuk sistem reaktif adalah pengiriman pesan, yang menciptakan batas waktu antar komponen, memungkinkan mereka dipisahkan dalam waktu menggunakan paralelisme dan ruang, yang mendistribusikan beban dan menyediakan mobilitas. Pemisahan ini merupakan persyaratan untuk isolasi lengkap antar komponen dan membentuk dasar untuk stabilitas dan ketahanan sistem.
Dasar-dasar Pemrograman Reaktif
Pemrograman ini berfokus pada aliran informasi dan penyebaran perubahan data. Saat menggunakan bahasa pemrograman, mudah untuk memisahkan aliran statis dan dinamis, sedangkan model yang mendasarinya akan secara otomatis menyebarkan perubahan melalui semua aliran data. Sederhananya, dalam pemrograman Rx, yang dipancarkan oleh satu komponen, dan struktur dasar yang disediakan oleh pustaka Rx, akan menyebarkan perubahan tersebut ke komponen lain yang didaftarkan untuk menerima perubahan tersebut. Pemrograman reaktif Rx terdiri dari tiga poin utama.
Fungsi utama komponen:
- Yang dapat diamati hanyalah aliran data. Paket data yang dapat diamati yang dapat diteruskan dari satu aliran ke aliran lainnya. Mereka pada dasarnya memancarkan data secara berkala atau hanya sekali dalam siklus hidupnya berdasarkan konfigurasi. Ada berbagai operator yang dapat membantu pengamat mengirimkan beberapa data spesifik berdasarkan kejadian tertentu.
- Pengamat mengkonsumsi aliran data yang dipancarkan oleh yang dapat diamati. Pengamat berlangganan menggunakan metode pemrograman reaktif subscribeOn() untuk menerima data yang diteruskan ke yang dapat diamati. Setiap kali data yang dapat diamati mengirimkan, semua pengamat yang terdaftar menerima data dalam callback onNext(). Di sini mereka dapat melakukan berbagai operasi seperti mem-parsing respons JSON atau memperbarui antarmuka pengguna. Jika ada kesalahan yang disebabkan oleh yang diamati, pengamat akan mendapatkannya di onError().
- Penjadwal (penjadwalan) adalah komponen dalam Rx yang memberi tahu yang dapat diamati dan pengamat di utas mana yang harus mereka jalankan. Anda dapat menggunakan metode observOn() untuk memberi tahu pengamat di utas mana yang harus mereka tonton. Atau, schedOn() dapat digunakan untuk memberi tahu yang dapat diamati di utas mana yang harus mereka jalankan.
Dalam pemrograman reaktif menggunakan utas inti default RxJava seperti Schedulers.newThread() akan membuat latar belakang baru. Schedulers.io() akan mengeksekusi kode pada utas I/O.
Manfaat utama Rx adalah peningkatan pemanfaatan sumber daya komputasi pada perangkat keras multi-core dan multi-prosesor, peningkatan kinerja dengan mengurangi titik, dan meningkatkan kinerja dengan mengurangi titik serialisasi, menurut Hukum Amdahl dan Hukum Skalabilitas Universal Günther.
Manfaat kedua adalah produktivitas tinggi untuk pengembang karena paradigma pemrograman tradisional telah berjuang untuk menyediakan pendekatan yang sederhana dan dapat dipertahankan untuk menangani komputasi dan IO yang asinkron dan non-pemblokiran. Pemrograman reaktif fungsional menangani tugas-tugas ini karena biasanya menghilangkan kebutuhan koordinasi eksplisit antara komponen aktif.
Di mana Rx terjadi, proses pembuatan komponen dan komposisi alur kerja dibuat. Untuk memanfaatkan sepenuhnya eksekusi asinkron, mengaktifkan backpressure sangat penting untuk menghindari penggunaan sumber daya yang berlebihan atau tidak terbatas. Untuk memastikan kondisi stabil dalam hal aliran data, tekanan balik berbasis beban mengirimkan permintaan yang mengalir ke hulu dan menerima pesan.
Dengan demikian, keuntungan utama dari sistem ini adalah:
- Peningkatan kinerja - berkat kemampuan memproses data dalam jumlah besar dengan cepat dan konsisten.
- Peningkatan UX - karena aplikasi lebih responsif terhadap pengguna.
- Modifikasi dan pembaruan yang disederhanakan - berkat kode yang lebih mudah dibaca dan diprediksi.
Tetapi meskipun Pemrograman Reaktif adalah hal yang sangat berguna saat membangun perangkat lunak modern, untuk memikirkan sistem di level yang lebih tinggi, Anda perlu menggunakan alat lain - Arsitektur Reaktif untuk proses mendesain sistem reaktif. Selain itu, penting untuk diingat bahwa ada banyak paradigma pemrograman dan Rx hanyalah salah satunya, seperti alat apa pun, Rx tidak dirancang untuk semua kasus penggunaan.
Stabilitas Sistem Reaktif
Ketangguhan adalah daya tanggap terhadap kegagalan dan merupakan properti fungsional yang melekat pada suatu sistem. Perlu pengembangan, bukan hanya penambahan retroaktif pada sistem. Ketahanan pemrograman javascript reaktif melampaui toleransi kesalahan dan itu bukan karena degradasi, tetapi jika terjadi kegagalan, itu dapat sepenuhnya memperbaiki dirinya sendiri.
Hal ini memerlukan isolasi komponen dan penahanan kesalahan untuk menghindari kegagalan yang menyebar ke komponen yang berdekatan, yang dapat menyebabkan skenario kaskade kegagalan bencana. Dengan demikian, kunci untuk membangun sistem Ketahanan adalah bahwa mereka dapat dicirikan sebagai pesan yang dikirim ke komponen lain yang bertindak sebagai pengawas dan dikelola dari konteks yang aman di luar komponen yang gagal.
Di sini, karena digerakkan oleh pesan, fasilitas ini menjauh dari rantai panggilan sinkron yang berpasangan erat, rapuh, dan bersarang dalam yang sebagian besar diabaikan. Idenya adalah untuk memisahkan penanganan kegagalan dari rantai panggilan, misalnya dengan membebaskan klien dari tanggung jawab menangani kegagalan server.
Karena sebagian besar sistem secara inheren kompleks, salah satu aspek terpenting adalah memastikan bahwa arsitektur sistem memastikan bahwa ada penurunan kinerja minimal dalam pengembangan dan pemeliharaan komponen, sementara pada saat yang sama mengurangi kompleksitas acak seminimal mungkin. Ini penting karena selama siklus hidup suatu sistem, jika tidak dirancang dengan benar, akan semakin sulit untuk membuatnya tetap berjalan, dan lebih banyak waktu dan upaya diperlukan untuk memahami untuk mengisolasi dan memperbaiki masalah.
Sistem reaktif mewakili arsitektur sistem yang paling produktif, dalam konteks arsitektur multi-core, cloud, dan seluler:
- Isolasi kesalahan menawarkan sekat antar komponen, mencegah kegagalan berjenjang dan membatasi ruang lingkup dan tingkat keparahan kegagalan.
- Hirarki supervisor menawarkan berbagai tingkat perlindungan yang digabungkan dengan kemampuan penyembuhan diri sendiri, yang meniadakan banyak kegagalan sementara dari setiap biaya operasional untuk diselidiki.
- Melewati pesan dan transparansi lokasi memungkinkan Anda menonaktifkan dan mengganti komponen tanpa memengaruhi pengalaman pengguna akhir. Ini mengurangi biaya kegagalan, urgensi relatifnya, dan sumber daya yang diperlukan untuk mendiagnosis dan memperbaikinya.
- Replikasi mengurangi risiko kehilangan data dan mengurangi dampak kegagalan pada ketersediaan pengambilan dan penyimpanan informasi.
- Elastisitas memungkinkan sumber daya dilestarikan saat penggunaan berfluktuasi, meminimalkan biaya operasional pada beban rendah dan risiko kegagalan atau investasi mendesak dalam skalabilitas saat beban meningkat.
Aplikasi web bisa sangat diuntungkan dari gaya pengembangan Rx, yang memungkinkan Anda menyusun alur kerja respons-permintaan yang mencakup percabangan ke panggilan layanan, pengambilan sumber daya asinkron dan komposisi respons, dan penyortiran berikutnya untuk klien. Baru-baru ini, peristiwa push-to-server dan soket web menjadi semakin umum dalam praktiknya, dan melakukan ini dalam skala besar memerlukan cara yang efisien untuk menyimpan banyak koneksi terbuka dan di mana IO tidak memblokir.
Ada alat untuk ini, seperti Streams dan Futures, yang membuat konversi non-pemblokiran dan asinkron menjadi mudah dan mendorongnya ke klien. Pemrograman Reaktif Lapisan Akses Data - Pembaruan dan kueri data dalam sumber daya yang efisien, sebaiknya menggunakan database SQL atau NoSQL dengan driver asinkron.
Aplikasi web juga mendapat manfaat dari pengembangan sistem reaktif untuk hal-hal seperti caching terdistribusi, konsistensi data, dan notifikasi multi-node. Aplikasi web tradisional biasanya menggunakan node berdiri. Tetapi segera setelah pemrogram mulai menggunakan Server-Sent-Events (SSE) dan WebSockets, node ini menjadi operasional, karena, minimal, mereka mempertahankan status koneksi klien, dan pemberitahuan push dikirimkan kepada mereka. Ini membutuhkan pengembangan sistem reaktif, karena ini adalah area di mana menangani penerima melalui pengiriman pesan adalah penting.
Inti dari pemrograman reaktif Java
Tidak wajib menggunakan Rx dalam sistem reaktif. Karena pemrograman Rx dan sistem reaktif bukanlah hal yang sama. Meskipun mereka sering digunakan secara bergantian, mereka bukanlah sinonim yang tepat dan mencerminkan hal yang berbeda. Sistem mewakili tingkat "reaktivitas" berikutnya. Level ini menyiratkan keputusan desain dan arsitektur khusus yang memungkinkan Anda membuat aplikasi yang kuat dan fleksibel.
Namun, ide yang sangat bagus - kombinasi metode - membawa lebih banyak manfaat bagi aplikasi, karena membuatnya lebih terhubung, memungkinkan penggunaan sumber daya yang lebih efisien, dan memberikan latensi yang lebih rendah. Ketika datang ke sejumlah besar data atau multitasking, pemrosesan asinkron sering diperlukan untuk menjaga sistem tetap cepat dan responsif.
Di Java, warisan pemrograman berorientasi objek lama, asinkron bisa menjadi sangat rumit dan membuat kode sulit dipahami dan dipelihara. Dengan demikian, Rx sangat berguna untuk lingkungan berorientasi objek "murni" ini karena membuatnya lebih mudah untuk bekerja dengan utas asinkron.
Dengan rilis terbarunya, dimulai dengan Java 8, Java sendiri telah melakukan beberapa upaya untuk mengimplementasikan reaktivitas asli, tetapi upaya ini tidak terlalu populer di kalangan pengembang saat ini. Namun, ada beberapa implementasi pihak ketiga yang aktif dan diperbarui secara rutin untuk pemrograman Java reaktif yang dapat menghemat waktu dan karena itu sangat dihargai oleh pengembang Java.
Dalam aplikasi biasa, beberapa operasi pemrograman reaktif sering dilakukan berulang kali menggunakan RxJava, jadi Anda perlu membandingkan kecepatan, penggunaan CPU, dan memori dengan operasi yang sama yang diterapkan dengan coroutine Kotlin dan RxJava. Ini adalah tes kinerja awal.
Setiap kali alat baru diterapkan yang akan digunakan secara luas di seluruh kode, penting untuk memahami apakah alat tersebut akan memengaruhi kinerja aplikasi secara keseluruhan sebelum memutuskan apakah layak menggunakannya. Praktik penggunaan memberikan jawaban singkat: dalam banyak kasus, pengguna harus mempertimbangkan untuk mengganti RxJava dengan coroutine Kotlin, terutama di Android.
Pemrograman reaktif menggunakan RxJava masih dapat digunakan dalam beberapa kasus, dan dalam kasus ini, RxJava dan coroutine dapat digabungkan.
Alasan sederhana:
- Mereka memberikan lebih banyak fleksibilitas daripada Rx biasa.
- Menyediakan kumpulan operator yang kaya pada koleksi yang akan terlihat sama dengan operator RxJava.
- Pemrograman reaktif Kotlin dapat berinteraksi saat dibutuhkan menggunakan rxjava.
- Mereka sangat ringan dan efisien mengingat penggunaan CPU yang lebih tinggi untuk pengumpulan sampah dari semua objek yang dibuat oleh RxJava.
Ekstensi reaktif
Ekstensi Reaktif (ReactiveX atau RX) adalah perpustakaan yang mengikuti prinsip-prinsip Rx yaitu menyusun program berbasis peristiwa dan asinkron menggunakan urutan yang dapat diamati. Pustaka ini menyediakan banyak antarmuka dan metode yang membantu pengembang menulis kode yang bersih dan sederhana.
Ekstensi reaktif tersedia dalam beberapa bahasa. Pemrogram sangat tertarik dengan RxJava dan RxAndroid karena android adalah area yang paling fokus.
Pemrograman reaktif menggunakan RxJava adalah implementasi dari Ekstensi Java Reaktif dari Netflix. Pada dasarnya ini adalah perpustakaan yang menyusun peristiwa asinkron mengikuti pola pengamat.
Dimungkinkan untuk membuat lalu lintas asinkron, mengubah dan mengkonsumsinya oleh pengamat dalam aliran data yang berbeda. Perpustakaan menawarkan berbagai operator luar biasa seperti peta, gabung, dan filter yang dapat diterapkan ke aliran data. Saat pemrogram mulai menggunakan contoh kode aktual, dia akan belajar lebih banyak tentang operator dan konversi.
Multithreading di Aplikasi Android
Android" class="if uuid-2938324" src="/misc/i/gallery/73564/2938324.jpg" />
Pemrograman Reaktif Android (RxAndroid) khusus untuk platform Android dengan beberapa kelas tambahan di atas RxJava. Lebih khusus lagi, penjadwal diperkenalkan di RxAndroid (AndroidSchedulers.mainThread()), yang berperan penting dalam mendukung konsep multithreading di aplikasi Android.
Antara lain, para ahli menyarankan untuk hanya menggunakan perpustakaan RxJava. Bahkan berkat banyaknya penjadwal yang digunakan dalam pemrograman android.
Di bawah ini adalah daftar penjadwal dan ringkasannya:
- Schedulers.io() - Digunakan untuk melakukan operasi non-intensif seperti panggilan jaringan, pembacaan disk/file, operasi basis data, dan yang memelihara kumpulan utas.
- AndroidSchedulers.mainThread() - Menyediakan akses ke tema Thread/UI utama. Biasanya, operasi dilakukan di utas ini, seperti memperbarui antarmuka pengguna, berinteraksi dengan pengguna. Para ahli menyarankan pengguna agar mereka tidak melakukan operasi intensif apa pun pada aliran ini, karena hal ini dapat menyebabkan aplikasi mogok atau dialog ANR.
- Schedulers.newThread() - Dengan ini, utas baru akan dibuat setiap kali tugas dijadwalkan. Umumnya disarankan untuk tidak menggunakan jadwal untuk pekerjaan yang sangat panjang. Thread yang dibuat dengan newThread() tidak akan digunakan kembali.
- Schedulers.computation() - Jadwal ini dapat digunakan untuk melakukan operasi intensif CPU, untuk memproses data besar dari pusat pemrograman reaktif, untuk memproses bitmap. Jumlah utas yang dibuat menggunakan penjadwal ini bergantung sepenuhnya pada jumlah inti CPU yang tersedia.
- Schedulers.single() - Penjadwal ini akan mengeksekusi semua tugas dalam urutan berikut, yang dapat digunakan saat kebutuhan eksekusi berurutan diperlukan.
- Schedulers.immediate() - Penjadwal ini segera mengeksekusi tugas dengan memblokir utas utama secara sinkron.
- Schedulers.trampoline() - Menjalankan tugas dalam mode First In-First Out. Semua tugas terjadwal akan berjalan satu per satu, membatasi jumlah utas latar menjadi satu.
- Schedulers.from () - memungkinkan Anda membuat penjadwal dari pelaksana, membatasi jumlah utas yang dibuat. Saat kumpulan utas sibuk, tugas akan diantrekan.
Sekarang setelah Anda memiliki latar belakang yang baik di RxJava dan RxAndroid, Anda dapat beralih ke beberapa contoh kode untuk lebih memahami konsepnya. Untuk memulai, Anda perlu menambahkan dependensi RxJava dan RxAndroid ke proyek build.gradle dan menyinkronkan proyek.
Pemrograman.
Pengamat berlangganan Observable sehingga dapat mulai menerima data menggunakan dua metode:
- SubscribeOn(Schedulers.io()) - Memberitahu Observable untuk memulai tugas di utas latar belakang.
- ObservOn(AndroidSchedulers.mainThread()) - Memberi tahu Pengamat untuk menerima data di thread UI Android.
Itu saja, agar programmer dapat menulis program pemrograman reaktif pertamanya dengan RxJava.
Perusahaan dan vendor middleware sudah mulai menggunakan Reaktif, dan 2016-2018 melihat peningkatan besar dalam minat perusahaan dalam mengadopsi paradigma ini.
Rx menawarkan kinerja pengembang melalui efisiensi sumber daya tingkat komponen untuk logika internal dan transformasi aliran data, sementara sistem reaktif menawarkan kinerja untuk arsitek dan DevOps melalui ketahanan dan elastisitas tingkat sistem. Mereka digunakan untuk membuat "Cloud Native" dan sistem terdistribusi skala besar lainnya. Dalam praktiknya, buku pemrograman reaktif Java juga banyak digunakan dengan metode yang memungkinkan Anda menggabungkan prinsip-prinsip desain sistem reaktif.
Memuat...