Strategi Mulakan Semula Lanjutan
Dalami strategi mulakan semula one_for_one, one_for_all dan rest_for_one serta fahami implikasinya terhadap toleransi kesalahan
Strategi Mulakan Semula Lanjutan ialah pelajaran Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP merangkumi sejumlah 4 pelajaran.
Pengenalan kepada Strategi Mula Semula
Selamat datang ke topik penting dalam Erlang: strategi mula semula! Strategi ini menentukan cara penyelia bertindak apabila salah satu proses anaknya terhenti akibat ralat.
Memahami strategi ini penting untuk membina sistem yang tahan terhadap kegagalan dan mampu pulih sendiri, yang merupakan ciri utama Erlang/OTP.
Penyelia: Pengurus Kegagalan
Sebelum kita meneruskan, mari ulang kaji secara ringkas: penyelia ialah proses khas yang memantau proses lain (anak prosesnya).
- Jika proses anak terhenti, penyelia akan mengesannya.
- Berdasarkan strategi mula semula yang dikonfigurasikan, penyelia menentukan cara memulihkan sistem kepada keadaan yang sihat.
- Hal ini memastikan aplikasi anda boleh pulih secara automatik daripada kegagalan proses individu.
`one_for_one`: Mula Semula Berasingan
Strategi one_for_one ialah strategi yang paling mudah dan paling biasa digunakan. Apabila proses anak ditamatkan:
- Hanya proses anak yang gagal dimulakan semula.
- Semua proses saudara yang lain tidak terjejas dan terus berjalan.
Strategi ini sesuai untuk sistem yang proses anaknya sebahagian besarnya tidak bergantung antara satu sama lain, seperti sambungan klien individu.
`one_for_one` dalam Tindakan
Mari lihat one_for_one. Kita akan mempunyai penyelia yang mengurus seorang pekerja. Apabila pekerja itu terhenti, hanya pekerja tersebut dimulakan semula.
Untuk menjalankan:
1. Susun: c(worker_gen). c(supervisor_one_for_one).
2. Mulakan penyelia: supervisor_one_for_one:start_link().
3. Hentikan pekerja secara paksa: worker_gen:crash(worker_1).
Perhatikan output dalam cangkerang Erlang anda.
-module(worker_gen).
-behaviour(gen_server).
-export([start_link/1, init/1, handle_call/3, terminate/2, crash/1]).
start_link(Id) ->
gen_server:start_link({local, Id}, ?MODULE, Id, []).
init(Id) ->
io:format("Worker ~p (~p) started.~n", [Id, self()]),
{ok, Id}.
handle_call(crash, _From, State) ->
exit(i_crashed),
{reply, ok, State};
handle_call(_Req, _From, State) ->
{reply, ok, State}.
terminate(_Reason, Id) ->
io:format("Worker ~p (~p) terminated.~n", [Id, self()]).
crash(Id) ->
gen_server:call(Id, crash).
-module(supervisor_one_for_one).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
ChildSpec = #{
id => worker_1,
start => {worker_gen, start_link, [worker_1]},
restart => permanent,
shutdown => 5000,
type => worker,
modules => [worker_gen]
},
{ok, #{
strategy => {one_for_one, 3, 5},
children => [ChildSpec]
}}.
`one_for_all`: Kegagalan Satu Menjejaskan Semua
Strategi one_for_all mengambil pendekatan yang lebih menyeluruh:
- Jika mana-mana proses anak ditamatkan, semua proses anak yang lain akan ditamatkan terlebih dahulu.
- Kemudian, semua proses anak (termasuk proses yang terhenti akibat ralat) dimulakan semula.
Strategi ini berguna apabila proses anak saling berkait rapat dan memerlukan keadaan yang konsisten serta disegerakkan. Kegagalan satu proses menunjukkan bahawa seluruh kumpulan perlu ditetapkan semula.
`one_for_all` dalam Tindakan
Di sini, penyelia mengurus dua pekerja. Hentikan salah satu daripadanya secara paksa, maka kedua-duanya akan dimulakan semula.
Untuk menjalankan:
1. Susun: c(worker_gen). c(supervisor_one_for_all).
2. Mulakan penyelia: supervisor_one_for_all:start_link().
3. Hentikan pekerja secara paksa: worker_gen:crash(worker_A).
Perhatikan bahawa kedua-dua worker_A dan worker_B dimulakan semula.
-module(worker_gen).
-behaviour(gen_server).
-export([start_link/1, init/1, handle_call/3, terminate/2, crash/1]).
start_link(Id) ->
gen_server:start_link({local, Id}, ?MODULE, Id, []).
init(Id) ->
io:format("Worker ~p (~p) started.~n", [Id, self()]),
{ok, Id}.
handle_call(crash, _From, State) ->
exit(i_crashed),
{reply, ok, State};
handle_call(_Req, _From, State) ->
{reply, ok, State}.
terminate(_Reason, Id) ->
io:format("Worker ~p (~p) terminated.~n", [Id, self()]).
crash(Id) ->
gen_server:call(Id, crash).
-module(supervisor_one_for_all).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
Child1 = #{
id => worker_A,
start => {worker_gen, start_link, [worker_A]},
restart => permanent, shutdown => 5000, type => worker, modules => [worker_gen]
},
Child2 = #{
id => worker_B,
start => {worker_gen, start_link, [worker_B]},
restart => permanent, shutdown => 5000, type => worker, modules => [worker_gen]
},
{ok, #{
strategy => {one_for_all, 3, 5},
children => [Child1, Child2]
}}.
`rest_for_one`: Mula Semula Berantai
Strategi rest_for_one menawarkan pendekatan pertengahan:
- Jika proses anak ditamatkan, proses itu dan semua anak proses selepasnya (yang ditakrifkan selepasnya dalam senarai anak penyelia) akan ditamatkan.
- Kemudian, anak proses yang gagal dan semua anak proses selepasnya dimulakan semula.
- Anak proses yang ditakrifkan sebelum anak proses yang gagal tidak terjejas.
Strategi ini berguna apabila proses mempunyai kebergantungan berjujukan, iaitu kegagalan pada peringkat awal mungkin membatalkan keadaan peringkat seterusnya.
`rest_for_one` dalam Tindakan
Kita mempunyai tiga pekerja: X, Y dan Z. Jika Y terhenti, Y dan Z dimulakan semula, tetapi X kekal aktif.
Untuk menjalankan:
1. Susun: c(worker_gen). c(supervisor_rest_for_one).
2. Mulakan penyelia: supervisor_rest_for_one:start_link().
3. Hentikan pekerja secara paksa: worker_gen:crash(worker_Y).
Lihat worker_X terus berjalan, manakala worker_Y dan worker_Z dimulakan semula.
-module(worker_gen).
-behaviour(gen_server).
-export([start_link/1, init/1, handle_call/3, terminate/2, crash/1]).
start_link(Id) ->
gen_server:start_link({local, Id}, ?MODULE, Id, []).
init(Id) ->
io:format("Worker ~p (~p) started.~n", [Id, self()]),
{ok, Id}.
handle_call(crash, _From, State) ->
exit(i_crashed),
{reply, ok, State};
handle_call(_Req, _From, State) ->
{reply, ok, State}.
terminate(_Reason, Id) ->
io:format("Worker ~p (~p) terminated.~n", [Id, self()]).
crash(Id) ->
gen_server:call(Id, crash).
-module(supervisor_rest_for_one).
-behaviour(supervisor).
-export([start_link/0, init/1]).
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
init([]) ->
ChildA = #{
id => worker_X,
start => {worker_gen, start_link, [worker_X]},
restart => permanent, shutdown => 5000, type => worker, modules => [worker_gen]
},
ChildB = #{
id => worker_Y,
start => {worker_gen, start_link, [worker_Y]},
restart => permanent, shutdown => 5000, type => worker, modules => [worker_gen]
},
ChildC = #{
id => worker_Z,
start => {worker_gen, start_link, [worker_Z]},
restart => permanent, shutdown => 5000, type => worker, modules => [worker_gen]
},
{ok, #{
strategy => {rest_for_one, 3, 5},
children => [ChildA, ChildB, ChildC]
}}.
Memilih Strategi Terbaik
Pemilihan strategi yang tepat bergantung pada seni bina aplikasi dan kebergantungan proses anda:
one_for_one: Gunakan untuk proses bebas, seperti sambungan klien individu atau pengendali permintaan.one_for_all: Sesuai untuk proses yang saling berkait rapat dan mesti sentiasa berada dalam keadaan konsisten secara bersama (contohnya, sekumpulan proses yang mengurus satu sumber).rest_for_one: Sesuai untuk saluran paip berjujukan atau sistem berlapis yang peringkat seterusnya terjejas apabila berlaku kegagalan pada peringkat terdahulu.
Uji Pengetahuan Anda
Anda sedang membina sistem yang mempunyai seorang pekerja utama untuk mendapatkan data, serta dua pekerja sekunder yang memproses aspek berbeza daripada data tersebut. Jika pekerja utama gagal, pekerja sekunder tidak boleh meneruskan pemprosesan dengan data lama dan mesti dimulakan semula. Jika seorang pekerja sekunder gagal, pekerja yang lain tidak terjejas. Apakah strategi yang paling sesuai untuk pekerja utama dan pekerja sekunder yang bergantung padanya?
Ringkasan: Menguasai Mula Semula
Anda telah meneroka strategi mula semula Erlang yang berkuasa:
one_for_one: Hanya memulakan semula anak proses yang gagal, manakala proses lain terus berjalan.one_for_all: Memulakan semula semua anak proses jika salah satu daripadanya gagal untuk memastikan konsistensi menyeluruh.rest_for_one: Memulakan semula anak proses yang gagal dan semua anak proses selepasnya dalam senarai.
Strategi ini menjadi asas untuk membina aplikasi Erlang yang kukuh dan mampu pulih sendiri, sekali gus membolehkan sistem anda pulih daripada kegagalan secara teratur.
Pelajari Erlang 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
Soalan Lazim
Adakah pelajaran “Strategi Mulakan Semula Lanjutan” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP, termasuk “Strategi Mulakan Semula Lanjutan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Strategi Mulakan Semula Lanjutan”?
Dalami strategi mulakan semula one_for_one, one_for_all dan rest_for_one serta fahami implikasinya terhadap toleransi kesalahan Anda berlatih Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP 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 Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP 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 “Strategi Mulakan Semula Lanjutan” 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 Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP ini?
Ya. Setiap pelajaran Pengaturcaraan Sistem Teragih dan Tahan terhadap Kegagalan dengan Erlang OTP 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
- Pepohon Penyeliaan Rumit
- Pengurusan Proses Dinamik
- Strategi Mulakan Semula Lanjutan
- Jambatan Penyelia dan Hierarki Proses Campuran