DEV Community: MYTC

algorithm ဆိုတာ ?

MYTC — Tue, 24 Feb 2026 10:08:36 +0000

algorithm ဆိုတာ logic စဥ်းစားပုံ စဥ်းစားနည်းပဲ အနားအလည် ဆုံး ဖြစ်အောင် ထမင်းကြော် ရဲ့ algorithm ကို ပြောပြမယ်

ပါဝင်ပစ္စည်းက ထမင်း၊ ကြက်ဥ၊ ဆီ
ကြက်သွန်။

လိုချင်တာ က ထမင်းကြော်

ပါဝင်ပစ္စည်း သိပြီ လိုချင်တာကို လည်း သိပြီ ဆိုရင်

လိုချင်တာကို အဆင့်ဆင့် ဘယ်လို လုပ်ရမလဲ ဆိုတာက algorithm ပဲ

ထမင်းကြော်ရဲ့ algorithm

ဒယ်အိုး တည်ပါ။

ဆီထည့်ပါ။

ကြက်သွန် ဆီသတ်ပါ။

ထမင်းထည့်မွှေပါ၊၊

ကြက်ဥ ထည့်ပါ။

ပြီးရင် အရသာ အတွက် အချို အငန် အပေါ့ ကိုယ်ကြိုက်သလို ထပ်ထည့်ပေါ့

algorithm ဆိုတာ ဘာမှ မဟုတ်ဘူး လိုချင်တာ ဖြစ်ချင်တာကို တစ်ဆင့်ပြီး တစ်ဆင့် ဘယ်လို လုပ်မလဲ ဆိုတာကို စဥ်းစားတာပဲ

ထမင်းကြော် တယ့်အခါ မှာ ဒယ်အိုးတည်ပြီး ထမင်းထည့်မွှေ လို့ မရဘူး အဲ့လို လုပ်တယ်ဆိုရင် အဲ့ တာ Algorithm မှားနေ တာပဲ

Algorithm ဆိုတာ သိပြီဆိုရင် Algorithm တစ်ခု ရဲ့ Performance ကို တိုင်းတာတဲ့
Big-O Notation ဆိုတာ ကို ဆက်လေ့လာ ထားရမယ်

program တစ်ခုကို Performance တိုင်းတာတယ့် အခါမှာ ရိုးရိုး အချိန် နာရီ နဲ့သွားပြီး
တိုင်းတာ လို့ မရဘူး ဘာလို့ ဆို computer ရဲ့ Hardware ပေါ် မူတည်ပြီး
အချိန်က ပြောင်းလဲနိုင်လို့ပဲ

Big-O Notation က အချိန် (Time) ကို တိုက်ရိုက်မတိုင်းဘဲ၊ Data ပမာဏ များလာတာနဲ့အမျှ Growth Rate ဘယ်လောက် ပိုကြာသွားမလဲ ဆိုတာကို တိုင်းတာပါတယ်။

Time Complexity: Data များလာရင် ဘယ်လောက် ပိုကြာသွားမလဲ။
Space Complexity: Data များလာရင် RAM (Memory) ဘယ်လောက် ပိုစားမလဲ။

ဆိုပြီး အဓိက အပိုင်း ၂ ပိုင်းနဲ့ တိုင်းတာ လေ့ ရှိတယ်

ထမင်းကြော်ဥပမာ နဲ့ Big-O Notation ကို ရှင်းပြ မယ်

ထမင်းကြော် ၁ ပွဲ ကြော် တာ နဲ့ ပွဲ ၁၀၀ ကြော်တာ နဲ့ ဘယ် ဟာက အချိန် ပိုကြာ မလဲ
ရှင်းပါတယ် ပွဲ ၁၀၀ ကြော် တာက အချိန်ပိုကြာ မှာ ပေါ့

ထမင်းကြော်တယ့် Algorithm ကို သိပြီးသားဆိုတော့ ပွဲ ၁၀၀ ကြော် ရင် အချိန်အများကြီး မကြာ အောင် လုပ်ဖို့ဆို ဘယ်နည်းလမ်းက အချိန် ပိုကြာမလဲ ဆိုတာ သိရမယ်
ကြာချိန်ကို သိရဖို့ ဆို Big-O Notation နဲ့ တိုင်းတာ ရတော့ မယ်

အယောက် ၁၀၀ အတွက် ထမင်းကြော်ကို တစ်ခါတည်း ကြော်မလား
၁ ပွဲ ချင်းစီ ကြော်မလား ဆိုတာ စဥ်းစားရတော့ မယ်

၁ ပွဲ ချင်းစီ ခွဲပြီး ကြော်နေ ရင်တော့ အချိန်တွေ အများကြီး ကြာမှာပေါ့

Algorithm က တော့ မှန်တယ် ဒါမယ့် Big-O Notation ကိုသေချာ မသိဘူးဆိုရင် မလို အပ်ပဲ အချိန်အများကြီး ကြာနေ လိမ့်မယ်
programming မှာ ဆို ရင် result တော့ ထွက်တယ် performance တော့ မကောင်းဘူးပေါ့

တစ်ပွဲချင်းစီ ကြော်တာ (Linear Time - O( n )): လူ ၁၀၀ အတွက် အခါ ၁၀၀ ကြော်ရမယ်။ လူများရင် များသလောက် အချိန်ကြာမယ်။

O( 1 ),O( n ) ဆိုတာက Big-O Type တွေ ကျန်တာ တွေ ရှိသေးတယ် သိချင်ရင်တော့ ကိုယ့်ဘာသာ ဆက်ပြီးလေ့လာကြည့် ကြပါ

array က ram ပေါ်မှာ ဒေတာ တွေ ဘယ်လို သိမ်းလဲ?

MYTC — Tue, 24 Feb 2026 10:03:36 +0000

ram ဆိုတာ ယာယီ မှတ်ဉာဏ် တစ်ခုပဲ cell လေးတွေ သန်းပေါင်းများစွာပါဝင်တယ်

cell တစ်ခု မှာ 1 Bit(0 or 1) ကို သိမ်းဆည်းနိုင်တယ် ဒါပေမယ့် CPU က ram ကို ကိုင်တွယ်တယ့် အခါ Bit ကို မကိုင်တွယ်ပါဘူး

ဘာလို့ ဆို number 1 ကို သိမ်းဖို့ဆိုရင်တောင် 1 Bit နဲ့ မလုံလောက်ပါဘူး

int 1 ဆိုရင် 32 bits လောက်နေရာ ယူပါတယ် C# မှာ long 1 လို့ သိမ်းခဲ့ရင် 8 bytes စာ နေရာယူပါတယ် javascript မှာ ဆိုရင် int ဆိုပြီး မခွဲတော့ ပဲ 8 bytes စာ နေရာယူပါတယ် ဒါကြောင့် Byte ကို ပဲ ကိုင်တွယ်ပါတယ် 8 bits(1 Byte) ကို Address တစ်ခု သတ်မှတ်ပါတယ်

program မှာ Array တစ်ခု တည်ဆောက်လိုက်တယ့် အခါ အဲ့ဒီ Array က ram မှာ လွှတ်နေ တယ့် cell အကွက်လေး မှာ သွားပြီး ကပ်လျက် ဒေတာ သိမ်းပါတယ်
[1,2,3,4] ဆိုပြီး array နဲ့ သိမ်းလိုက်တယ် ram ပေါ် မှာ လွှတ်နေ တယ့် address ကို သွားရှာမယ်

address 100 မှာ လွှတ်နေ တယ်ဆိုရင်
လွှတ်နေ တယ့် address 100 ကနေ စပြီး ဒေတာကို သိမ်းသွားမယ်

1 ဆိုတယ့် value ကို အရင် စပြီး သိမ်းမယ်
1 ဖြစ်တယ့် အတွက် bit နဲ့ မလုံလောက်ဘူး
လို အပ်တာ က 4 bytes စာနေရာလိုတယ်

1 byte မှာ address တစ်ခုသတ်မှတ်တာကြောင့် လိုအပ်တာက 4 bytes ဆိုတော့
address 4 ခု လိုမယ် လွှတ်နေတယ့် address က 100 အဲ့တော့
100,101,102,103 ဆိုတယ့် address မှာ 1 အတွက် နေရာယူမယ်

သိမ်းမယ့် value က 1, index က 0, address က 100 to 1003 cell အကွက်နဲ့ ဆိုရင် 32 ကွက်စာ နေရာ ယူသွားမယ် ဘာလို့ ဆို cell တစ်ကွက်မှာ 1 bit စာ ပဲ ရှိတယ် 8 bits ကို 1 Byte , 4 Bytes ဆိုတော့ 32 bits

1 ကို သက်ဆိုင်ရာ programming language က binary code အဖြစ် ပြောင်း 1 ရဲ့ binary code က 00000000 00000000 00000000 00000001 (စုစုပေါင်း 32 bits or cell အကွက် 32 ကွက်)

array ထဲက 1 ကို သိမ်းပြီးသွားပြီဆို တော့ 2 ကို ဆက်သိမ်းပါမယ် array နဲ့ ဒေတာ သိမ်းတာ ဖြစ်လို့ ကပ်လျပ်သိမ်းမှာပါ
index 0 = 1 ရဲ့ နောက်မှာ ဆက်ပြီးသိမ်းမှာ ဖြစ်လို့ 2 က address 104 ကနေ စပြီး 4 Byes စာနေ ရာ ယူမှာပါ

ဒါကြောင့် array ရဲ့ index ကို သိရင် ဒေတာ ရှာ ရတာ အရမ်းလွှယ်ပါတယ်
ဘာလို့ဆို index သိရင် address ကို သိလို့ပါ

index ကို သိရင် address ကို ဘယ်လို သိလဲ ဆိုရင် CPU က အောက်ပါ Formula ကို သုံးပြီး ရှာပါတယ်

Target Address = Start Address + (Index * Data Size)

ဒီမှာ data size and start address ကို ဘယ်လို သိလဲ ဆိုတာ ထပ်ရှင်းပါမယ်
data size ဆိုတာ က array ကို ဆောက်တုန်းက သတ်မှတ်ထားတယ့် data type အပေါ် မူတည် ပြီး ယူပါတယ်

C# and javascript ကို သုံးပြီး array ဆောက်ပြီး ရှင်းပြပါမယ်

C# code

byte[] levels = { 1, 5, 10, 20 };

byte လို့ ကြေညာ ထားတယ့် အတွက် data size က 1 byte ပါ

double[] prices = { 10.5, 20.0, 99.9 };

double လို့ ကြေညာထားတယ့် အတွက် data size က 8 bytes ပါ

string[] names = { "A", "Myanmar", "Hello World" };

string လို့ ကြေညာ ထားရင် data size က တူညီတော့ ပါဘူး

array မှာ သတ်မှတ်ထားတယ့် စည်းမျဥ်းရှိပါတယ် array ထဲမှာ သိမ်းထားတယ့် data အားလုံးရဲ့ data size က တူညီရမှာပါ
data size တူညီမှ Forumla ကို သုံးပြီး target address ကို ရှာနိုင်မှာ မို့လို့ပါ

string ဆိုရင် စာလုံး အရှည်အတို အပေါ် မူတည်ပြီး data size က ကွာခြားနိုင်ပါတယ်

string ဆိုရင် ဘယ်လို နေရာ ယူသွားလဲ ဆိုရင် data size ကို 8 bytes လို့ ပဲ default သတ်မှတ်ပြီး Reference Address ကို ပဲ သိမ်းပါတယ်

Reference Address ဆိုတာ Head Memory မှာ ရှိတယ့် Address ကို သွားပြီး ညွှန်တာပါ

programming language တွေက RAM ကို အပိုင်းတွေ ခွဲပြီး အသုံးပြု ပါတယ်

ဒီလောက်ဆိုရင်တော့ array တစ်ခု ram ပေါ် မှာ ဘယ်လို နေရာ ယူလဲ ဘာကြောင့် Array မှာ index သိရင် data ကို ဘာလို့ မြန်မြန် ယူ လို့ ရနေ လဲ ဆိုတာ သိလောက်ပြီ ထင်ပါတယ််

Concurrent Requests များကို ဘယ်လို ကိုင်တွယ်ဖြေရှင်းမလဲ?

MYTC — Tue, 24 Feb 2026 09:58:21 +0000

System တစ်ခုကို User အများအပြားက တစ်ချိန်တည်း (Exact same time) မှာ အသုံးပြုတဲ့အခါ Data တွေ မှားယွင်းသွားတတ်တဲ့ "Race Condition" ဆိုတဲ့ ပြဿနာကို ကြုံရလေ့ရှိပါတယ်

ဥပမာ အနေ နဲ့ E-commerce မှာ တစ်ခု တည်း ကျန်တယ့် ပစ္စည်း တစ်ခုကို User နှစ်ယောက် က ပြိုင်တူ ဝယ် တယ့် အခါ မျိုး Online ကနေ ticket များကို user အများအပြားက တစ်ပြိုင်တည်း ဝယ်တယ့် အခါမျိုး ဒီလို အခြေအနေ များမှာ Race Condition ဖြစ်သွားပြီး ပြသာနာ ကြုံရတတ်ပါတယ်

ဒီလိုပြသာနာ တွေ ကို ဖြေရှင်းလို့ ရတယ့် နည်းလမ်းတွေက တော့ တစ်ခုထက်မက ရှိပါတယ် ဘယ် နည်းလမ်းကို သုံးပြီးဖြေရှင်း မလဲ ဆိုတာကတော့ ကိုယ့်ရဲ့ project ပေါ်မှာ ပဲ မူတည်ပါတယ်

Database Level မှာတာ့ Pessimistic Locking, Optimistic Locking များကို သုံးပြီး Race Condition ကို ဖြေရှင်းလို့ရပါတယ်

Pessimistic Locking ဆိုတာက Data ကို ဖတ်ပြီး ပြင်ဆင်နေချိန် (Transaction အလုပ်လုပ်နေချိန်) မှာ အခြားဘယ်သူမှ ဝင်ပြင်လို့မရအောင် Lock ချထားတဲ့ စနစ်ပါ။ (ဥပမာ - SQL မှာ SELECT ... FOR UPDATE သုံးတာမျိုး)။ Data accuracy အရမ်းအရေးကြီးတဲ့ နေရာတွေမှာ သုံးလို့ကောင်းပေမယ့် User အများကြီး ဝင်သုံးတဲ့အခါ Performance ကိုတော့ သိသိသာသာ ကျဆင်းစေနိုင်ပါတယ်။

Optimistic Locking ဆိုတာက
Lock အသေမချထားဘဲ Table ရဲ့ Record တစ်ခုချင်းစီမှာ Version number (သို့) Timestamp လေးတွေ ထည့်ထားတဲ့နည်းပါ ကိုယ် Update လုပ်မယ့်အချိန်ရောက်မှ Database ထဲက Version နဲ့ ကိုယ်ယူလာတဲ့ Version ကိုက်/မကိုက် စစ်ဆေးပါတယ် Version မကိုက်တော့ဘူး (တခြားတစ်ယောက်က အရင်ဝင်ပြင်သွားတယ်) ဆိုရင် Exception ပစ်ချပြီး Retry ခိုင်းပါတယ်

System က Server တစ်လုံးတည်း မဟုတ်ဘဲ Microservices တွေ၊ Web Servers အများကြီးနဲ့ Run နေတဲ့ အခြေအနေမျိုးမှာဆိုရင် Database ကိုချည်းပဲ အားကိုးလို့ အဆင်မပြေနိုင်ပါဘူး

Redis ရဲ့ INCR, DECR ဒါမှမဟုတ် Code ထဲမှာဆိုရင် StringIncrementAsync လိုမျိုး Atomic Command တွေကို သုံးပြီး ဖြေရှင်းတာက ပိုပြီးထိရောက်ပါတယ် Redis က Single-threaded Architecture ဖြစ်တဲ့အတွက် Request တွေကို တစ်ပြိုင်တည်း လာနေရင်တောင် တစ်ခုပြီးမှ တစ်ခု (Sequential) အလုပ်လုပ်ပေးသွားပါတယ်
ဒါကြောင့် Counter တွေ၊ တစ်ခုတည်းကျန်တဲ့ Ticket အရေအတွက် လျှော့တာတွေ၊ Unique ဖြစ်တဲ့ Barcode သို့မဟုတ် ID တွေ ထုတ်ပေးတဲ့ နေရာတွေမှာ Race condition မဖြစ်အောင် အကောင်းဆုံး တားဆီးပေးနိုင်ပါတယ်

Application Level Locking ကိုသုံးပြီး လည်း Race Condition ကို ဖြေရှင်းလို့ရပါတယ်
Code ရေးတဲ့အခါ Thread တွေ အများကြီး ပြိုင်မလုပ်နိုင်အောင် ကန့်သတ်တဲ့ နည်းလမ်းပါ
C# လို Language မှာဆိုရင် lock keyword, Mutex, ဒါမှမဟုတ် Asynchronous programming အတွက်ဆိုရင် SemaphoreSlim စတာတွေကို သုံးပြီး အရေးကြီးတဲ့ Code block (Critical Section) ကို တစ်ချိန်မှာ Thread တစ်ခုတည်းကပဲ ဝင်ရောက်ခွင့်ပြုအောင် ထိန်းချုပ်တာပါ
ဒီနည်းလမ်းက Server တစ်လုံးတည်း (Single Instance) မှာပဲ အလုပ်လုပ်ပြီး Server အများကြီးနဲ့ Run တဲ့အခါမှာတော့ အဆင်မပြေပါဘူး

User တွေဆီက လာတဲ့ Request တွေကို တိုက်ရိုက် Process မလုပ်ဘဲ RabbitMQ သို့မဟုတ် Kafka စတဲ့ Message Broker (Queue) တွေထဲကို အရင်ထည့်ပြီး နောက်က Background Worker ကနေ Queue ထဲကနေ တစ်ခုချင်းစီ အစဉ်လိုက် ဆွဲယူပြီး Database ကို အလုပ်လုပ်ခိုင်းတဲ့နည်းလမ်းကို သုံးပြီးလည်း ဖြေရှင်းလို့ရပါတယ်