Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM · Pelajaran

Janji, Masa Hadapan dan Operasi Tak Segerak

Terokai corak pengaturcaraan tak segerak dalam Clojure untuk mengendalikan tugasan jangka panjang dan I/O tanpa sekatan

Pelajaran 3 daripada 411 langkah

Janji, Masa Hadapan dan Operasi Tak Segerak ialah pelajaran Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM merangkumi sejumlah 4 pelajaran.

Pengenalan kepada Pengaturcaraan Tak Segerak

Selamat datang! Dalam pelajaran ini, kita akan meneroka pengaturcaraan tak segerak dalam Clojure. Ini penting untuk membina aplikasi responsif yang tidak terhenti sementara menunggu tugasan yang panjang.

Tugasan tak segerak berjalan di 'latar belakang', membolehkan atur cara utama anda terus berjalan tanpa gangguan. Apabila tugasan latar belakang selesai, tugasan itu menghantar hasilnya.

Menyekat berbanding Tidak Menyekat

Bayangkan anda mendapatkan data daripada pelayan yang perlahan. Operasi menyekat akan menyebabkan aplikasi anda menunggu sehingga data tiba. Sepanjang masa ini, tiada perkara lain boleh berlaku.

Operasi tidak menyekat memulakan pengambilan data tetapi segera mengembalikan kawalan kepada aplikasi anda. Aplikasi anda kemudian boleh melakukan perkara lain dan memproses data apabila data itu tersedia.

Makro 'future' Clojure

Clojure menyediakan makro future untuk menjalankan pengiraan dalam jalur berasingan. Ini menjadikan pengiraan tersebut tak segerak dan tidak menyekat dari perspektif pemanggil.

future segera mengembalikan objek 'future', iaitu ruang letak untuk hasil yang akan diperoleh kemudian.

Menggunakan 'future' untuk Tugasan Tak Segerak

Mari lihat future beraksi. Kita akan mensimulasikan tugasan yang berjalan lama menggunakan Thread/sleep. Perhatikan bahawa mesej "Future started" muncul serta-merta.

(ns my-app.core
  (:gen-class))

(defn -main
  "Demonstrates a simple future."
  [& args]
  (println "Main thread: Starting future...")
  (let [f (future
            (println "  Future thread: Working...")
            (Thread/sleep 2000) ; Simulate work
            (println "  Future thread: Done!")
            "Result from Future")]
    (println "Main thread: Future started, continuing...")
    ; We'll learn how to get the result next!
    (Thread/sleep 1000) ; Let main thread do other work
    (println "Main thread: End of main.")))

Mendapatkan Hasil daripada 'future'

Untuk mendapatkan nilai sebenar daripada future, anda perlu menyahrujuknya. Anda boleh menggunakan makro pembaca @ atau fungsi deref.

Jika pengiraan future masih belum selesai, penyahrujukan akan menyekat jalur semasa sehingga hasilnya tersedia.

(ns my-app.core
  (:gen-class))

(defn -main
  "Dereferencing a future."
  [& args]
  (println "Main thread: Starting future...")
  (let [f (future
            (println "  Future thread: Working...")
            (Thread/sleep 2000)
            "Long Task Complete")]
    (println "Main thread: Future launched.")
    (println "Main thread: Doing other work...")
    (Thread/sleep 500)
    (println "Main thread: Now waiting for future result...")
    (let [result @f] ; Dereference the future
      (println "Main thread: Future result:" result))
    (println "Main thread: All done!")))

Fungsi 'promise' Clojure

Walaupun future menjalankan pengiraan, promise ialah ruang letak untuk nilai yang akan diserahkan kemudian, biasanya oleh jalur lain atau peristiwa luaran.

Anggaplah ia sebagai kotak kosong yang akan diisi oleh orang lain. Anda boleh menunggu kotak itu diisi dengan menyahrujuknya.

Menyerahkan dan Menyahrujuk Promise

Fungsi deliver digunakan untuk memasukkan nilai ke dalam promise. Setelah promise diserahkan, nilainya tidak boleh diubah.

Menyahrujuk promise berfungsi sama seperti future: ia akan menyekat sehingga nilai diserahkan.

(ns my-app.core
  (:gen-class))

(defn -main
  "Delivering and dereferencing a promise."
  [& args]
  (let [p (promise)]
    (println "Main thread: Created a promise.")
    (future
      (println "  Future thread: Doing async work...")
      (Thread/sleep 1500)
      (let [val "Value from Future!"]
        (println "  Future thread: Delivering value to promise.")
        (deliver p val)))
    (println "Main thread: Waiting for promise to be delivered...")
    (let [result @p] ; Blocks until 'deliver' is called
      (println "Main thread: Promise received:" result))
    (println "Main thread: Program finished.")))

Future dan Promise Bersama

future dan promise sering berfungsi bersama. future mungkin menjalankan pengiraan yang rumit, kemudian deliver hasilnya kepada promise, yang kemudiannya boleh diambil oleh bahagian lain aplikasi anda.

Pola ini berguna untuk menyelaraskan tugasan atau jalur tak segerak yang berbeza.

(ns my-app.core
  (:gen-class))

(defn long-calculation []
  (println "  Calculation: Starting...")
  (Thread/sleep 2500) ; Simulate heavy work
  (println "  Calculation: Finished.")
  (* 123 456))

(defn -main
  "Coordinating with future and promise."
  [& args]
  (let [calc-promise (promise)]
    (println "Main: Kicking off calculation...")
    (future ; Run calculation in a separate thread
      (let [result (long-calculation)]
        (deliver calc-promise result)))
    (println "Main: Calculation started. Doing other things...")
    (Thread/sleep 1000)
    (println "Main: Still doing other things...")
    (println "Main: Waiting for calculation result...")
    (let [final-result @calc-promise]
      (println "Main: Received final result:" final-result))
    (println "Main: Done.")))

Pengendalian Ralat dengan Tugasan Tak Segerak

Apabila pengecualian berlaku dalam future atau sebelum promise diserahkan, penyahrujukan future/promise akan melontarkan semula pengecualian itu pada jalur penyahrujukan.

Ini membolehkan anda mengendalikan ralat dalam jalur utama, walaupun ralat itu berpunca daripada tugasan tak segerak.

Semakan Pantas: Kelakuan Tak Segerak

Pertimbangkan coretan kod Clojure berikut:

(let [f (future (Thread/sleep 1000) "Async Result")]
  (println "Started")
  (Thread/sleep 500)
  (println "Waiting...")
  (let [result @f]
    (println "Got:" result)))

Apakah jumlah masa minimum sebelum "Got: Async Result" dicetak?

Jawab dalam pelajaran interaktif

Imbas Kembali: Promises, Futures & Tak Segerak

Pengaturcaraan tak segerak membolehkan tugasan berjalan tanpa menyekat aliran atur cara utama.
Makro future Clojure menjalankan pengiraan dalam jalur berasingan dan mengembalikan ruang letak dengan serta-merta.
Fungsi promise mencipta ruang letak yang boleh deliver nilai kemudian, selalunya daripada jalur lain atau sumber luaran.
Kedua-dua future dan promise dinyahrujuk (menggunakan @ atau deref) untuk mendapatkan nilainya dan akan menyekat jika nilai belum tersedia.
Pengecualian dalam tugasan tak segerak dilontarkan semula apabila dinyahrujuk.

Percuma untuk bermula

Pelajari Clojure dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Janji, Masa Hadapan dan Operasi Tak Segerak” percuma?

Ya — teks penuh “Janji, Masa Hadapan dan Operasi Tak Segerak” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM, tingkat taraf kepada CoddyKit PRO. Kursus Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Janji, Masa Hadapan dan Operasi Tak Segerak”?

Terokai corak pengaturcaraan tak segerak dalam Clojure untuk mengendalikan tugasan jangka panjang dan I/O tanpa sekatan Anda berlatih Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Janji, Masa Hadapan dan Operasi Tak Segerak” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM ini?

Ya. Setiap pelajaran Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Ref, Ejen dan Atom untuk Keadaan
Memori Transaksi Perisian (STM)
Janji, Masa Hadapan dan Operasi Tak Segerak
Saluran core.async dan Blok Go

← Kembali ke Pengaturcaraan Fungsian Clojure dan Pembangunan Bahagian Belakang JVM