Mayroong ilang mga primitive ng synchronization na ginagamit sa computational architecture, kabilang ang:
1. Locks: Ang mga lock ay isang uri ng synchronization primitive na ginagamit upang matiyak na isang thread o proseso lamang ang nag-a-access sa isang shared resource sa isang pagkakataon. Karaniwang ginagamit ang mga lock upang maiwasan ang mga kundisyon ng lahi kung saan sinusubukan ng dalawa o higit pang mga thread na i-access ang parehong mapagkukunan nang sabay-sabay.
2. Semaphores: Ang mga semaphores ay isa pang uri ng primitive na synchronization na ginagamit upang kontrolin ang access sa mga shared resources. Hindi tulad ng mga lock, maaaring gamitin ang mga semaphore upang kontrolin ang pag-access sa isang tiyak na bilang ng mga mapagkukunan, sa halip na isa lamang.
3. Mga Monitor: Ang mga monitor ay isang mas mataas na antas ng pag-synchronize na primitive kaysa sa mga lock at semaphore. Pinapayagan ng mga monitor na mag-synchronize ang mga thread sa isang partikular na bagay, sa halip na sa isang generic na lock. Ginagawa nitong mas madali ang pagsulat ng code na ligtas sa thread na hindi gaanong madaling kapitan ng error.
4. Mga hadlang: Ang mga hadlang ay mga primitive sa pag-synchronize na nagpapahintulot sa mga thread na mag-synchronize sa isang partikular na punto sa code. Ang mga hadlang ay karaniwang ginagamit upang matiyak na ang lahat ng mga thread ay nakumpleto ang isang tiyak na gawain bago ang programa ay maaaring magpatuloy.
5. Atomic operations: Atomic operations ay isang uri ng synchronization primitive na nagbibigay-daan para sa atomic updates sa isang shared resource. Tinitiyak ng mga pagpapatakbo ng atom na ang lahat ng mga thread ay nakikita ang parehong halaga kapag nag-a-access sa isang nakabahaging mapagkukunan, at maaaring maiwasan ang mga kondisyon ng lahi at iba pang mga isyu sa pag-synchronize.
Petsa ng publikasyon: