🥇ಇಂಟರ್‌ಸಿಸ್ಟಮ್ಸ್ IRIS ಗ್ಲೋಬಲ್‌ಗಳಲ್ಲಿನ ವಹಿವಾಟುಗಳು

ಇಂಟರ್‌ಸಿಸ್ಟಮ್ಸ್ IRIS DBMS ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಆಸಕ್ತಿದಾಯಕ ರಚನೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ - ಜಾಗತಿಕ. ಮೂಲಭೂತವಾಗಿ, ಇವುಗಳು ವಹಿವಾಟುಗಳ ರೂಪದಲ್ಲಿ ವಿವಿಧ ಹೆಚ್ಚುವರಿ ಗುಡಿಗಳೊಂದಿಗೆ ಬಹು-ಹಂತದ ಕೀಗಳಾಗಿವೆ, ಡೇಟಾ ಟ್ರೀಗಳನ್ನು ಹಾದುಹೋಗಲು ವೇಗದ ಕಾರ್ಯಗಳು, ಲಾಕ್‌ಗಳು ಮತ್ತು ಅದರ ಸ್ವಂತ ಆಬ್ಜೆಕ್ಟ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆ.

“ಗ್ಲೋಬಲ್‌ಗಳು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿಧಿ-ಕತ್ತಿಗಳು” ಎಂಬ ಲೇಖನಗಳ ಸರಣಿಯಲ್ಲಿ ಗ್ಲೋಬಲ್‌ಗಳ ಕುರಿತು ಇನ್ನಷ್ಟು ಓದಿ:

ಮರಗಳು. ಭಾಗ 1
ಮರಗಳು. ಭಾಗ 2
ವಿರಳ ಸರಣಿಗಳು. ಭಾಗ 3

ಗ್ಲೋಬಲ್‌ಗಳಲ್ಲಿ ವಹಿವಾಟುಗಳನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಯಾವ ವೈಶಿಷ್ಟ್ಯಗಳಿವೆ ಎಂಬುದರ ಕುರಿತು ನಾನು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇನೆ. ಎಲ್ಲಾ ನಂತರ, ಪರಿಚಿತ ಕೋಷ್ಟಕಗಳಿಗಿಂತ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ರಚನೆಯಾಗಿದೆ. ಹೆಚ್ಚು ಕಡಿಮೆ ಮಟ್ಟ.

ಸಂಬಂಧಿತ ದತ್ತಸಂಚಯಗಳ ಸಿದ್ಧಾಂತದಿಂದ ತಿಳಿದಿರುವಂತೆ, ವಹಿವಾಟಿನ ಉತ್ತಮ ಅನುಷ್ಠಾನವು ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸಬೇಕು ಎಸಿಐಡಿ:

ಎ - ಪರಮಾಣು (ಪರಮಾಣು). ವಹಿವಾಟಿನಲ್ಲಿ ಮಾಡಿದ ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳು ಅಥವಾ ಯಾವುದನ್ನೂ ದಾಖಲಿಸಲಾಗಿಲ್ಲ.

ಸಿ - ಸ್ಥಿರತೆ. ವಹಿವಾಟು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಡೇಟಾಬೇಸ್‌ನ ತಾರ್ಕಿಕ ಸ್ಥಿತಿಯು ಆಂತರಿಕವಾಗಿ ಸ್ಥಿರವಾಗಿರಬೇಕು. ಅನೇಕ ವಿಧಗಳಲ್ಲಿ ಈ ಅವಶ್ಯಕತೆಯು ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಆದರೆ SQL ಡೇಟಾಬೇಸ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ವಿದೇಶಿ ಕೀಲಿಗಳಿಗೆ ಸಂಬಂಧಿಸಿದೆ.

ನಾನು - ಪ್ರತ್ಯೇಕಿಸಿ. ಸಮಾನಾಂತರವಾಗಿ ನಡೆಯುವ ವಹಿವಾಟುಗಳು ಪರಸ್ಪರ ಪರಿಣಾಮ ಬೀರಬಾರದು.

ಡಿ - ಬಾಳಿಕೆ ಬರುವ. ವ್ಯವಹಾರವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ಕೆಳ ಹಂತಗಳಲ್ಲಿನ ಸಮಸ್ಯೆಗಳು (ವಿದ್ಯುತ್ ವೈಫಲ್ಯ, ಉದಾಹರಣೆಗೆ) ವಹಿವಾಟಿನಿಂದ ಬದಲಾದ ಡೇಟಾದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಾರದು.

ಗ್ಲೋಬಲ್‌ಗಳು ಸಂಬಂಧವಿಲ್ಲದ ಡೇಟಾ ರಚನೆಗಳಾಗಿವೆ. ಅವುಗಳನ್ನು ಅತ್ಯಂತ ಸೀಮಿತ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಅತಿ ವೇಗವಾಗಿ ಚಲಾಯಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಬಳಸಿ ಜಾಗತಿಕ ವಹಿವಾಟುಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದನ್ನು ನೋಡೋಣ ಅಧಿಕೃತ IRIS ಡಾಕರ್ ಚಿತ್ರ.

IRIS ನಲ್ಲಿ ವಹಿವಾಟುಗಳನ್ನು ಬೆಂಬಲಿಸಲು, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ: TSTART, TCOMMIT, ಟ್ರೋಲ್ಬ್ಯಾಕ್.

1. ಪರಮಾಣು

ಪರೀಕ್ಷಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಪರಮಾಣು. ನಾವು ಡೇಟಾಬೇಸ್ ಕನ್ಸೋಲ್‌ನಿಂದ ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

Kill ^a
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TCOMMIT

ನಂತರ ನಾವು ತೀರ್ಮಾನಿಸುತ್ತೇವೆ:

Write ^a(1), “ ”, ^a(2), “ ”, ^a(3)

ನಾವು ಪಡೆಯುತ್ತೇವೆ:

1 2 3

ಎಲ್ಲವು ಚೆನ್ನಾಗಿದೆ. ಪರಮಾಣುತ್ವವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ: ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳನ್ನು ದಾಖಲಿಸಲಾಗಿದೆ.

ಕಾರ್ಯವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸೋಣ, ದೋಷವನ್ನು ಪರಿಚಯಿಸಿ ಮತ್ತು ವಹಿವಾಟನ್ನು ಹೇಗೆ ಉಳಿಸಲಾಗಿದೆ, ಭಾಗಶಃ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ಪರಮಾಣುತ್ವವನ್ನು ಮತ್ತೊಮ್ಮೆ ಪರಿಶೀಲಿಸೋಣ:

Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3

ನಂತರ ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಬಲವಂತವಾಗಿ ನಿಲ್ಲಿಸುತ್ತೇವೆ, ಅದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ನೋಡುತ್ತೇವೆ.

docker kill my-iris

ಈ ಆಜ್ಞೆಯು ಫೋರ್ಸ್ ಶಟ್‌ಡೌನ್‌ಗೆ ಬಹುತೇಕ ಸಮನಾಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ತಕ್ಷಣವೇ ನಿಲ್ಲಿಸಲು SIGKILL ಸಂಕೇತವನ್ನು ಕಳುಹಿಸುತ್ತದೆ.

ಬಹುಶಃ ವಹಿವಾಟನ್ನು ಭಾಗಶಃ ಉಳಿಸಲಾಗಿದೆಯೇ?

WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)

- ಇಲ್ಲ, ಅದು ಉಳಿದುಕೊಂಡಿಲ್ಲ.

ರೋಲ್ಬ್ಯಾಕ್ ಆಜ್ಞೆಯನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:

Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TROLLBACK

WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)

ಯಾವುದೂ ಉಳಿಯಲಿಲ್ಲ.

2. ಸ್ಥಿರತೆ

ಗ್ಲೋಬಲ್‌ಗಳನ್ನು ಆಧರಿಸಿದ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ, ಗ್ಲೋಬಲ್‌ಗಳಲ್ಲಿ ಕೀಗಳನ್ನು ಸಹ ತಯಾರಿಸಲಾಗುತ್ತದೆ (ಜಾಗತಿಕವು ಸಂಬಂಧಿತ ಕೋಷ್ಟಕಕ್ಕಿಂತ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಕೆಳಮಟ್ಟದ ರಚನೆಯಾಗಿದೆ ಎಂದು ನಾನು ನಿಮಗೆ ನೆನಪಿಸುತ್ತೇನೆ), ಸ್ಥಿರತೆಯ ಅಗತ್ಯವನ್ನು ಪೂರೈಸಲು, ಕೀಲಿಯಲ್ಲಿ ಬದಲಾವಣೆಯನ್ನು ಸೇರಿಸಬೇಕು ಜಾಗತಿಕ ಬದಲಾವಣೆಯಂತೆಯೇ ಅದೇ ವಹಿವಾಟಿನಲ್ಲಿ.

ಉದಾಹರಣೆಗೆ, ನಾವು ಜಾಗತಿಕ ^ವ್ಯಕ್ತಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ನಾವು ವ್ಯಕ್ತಿತ್ವಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು TIN ಅನ್ನು ಕೀಲಿಯಾಗಿ ಬಳಸುತ್ತೇವೆ.

^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
...

ಕೊನೆಯ ಹೆಸರು ಮತ್ತು ಮೊದಲ ಹೆಸರಿನ ಮೂಲಕ ತ್ವರಿತ ಹುಡುಕಾಟವನ್ನು ಹೊಂದಲು, ನಾವು ^ಇಂಡೆಕ್ಸ್ ಕೀಲಿಯನ್ನು ಮಾಡಿದ್ದೇವೆ.

^index(‘Kamenev’, ‘Sergey’, 1234567) = 1

ಡೇಟಾಬೇಸ್ ಸ್ಥಿರವಾಗಿರಲು, ನಾವು ಈ ರೀತಿಯ ವ್ಯಕ್ತಿತ್ವವನ್ನು ಸೇರಿಸಬೇಕು:

TSTART
^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
^index(‘Kamenev’, ‘Sergey’, 1234567) = 1
TCOMMIT

ಅಂತೆಯೇ, ಅಳಿಸುವಾಗ ನಾವು ವಹಿವಾಟನ್ನು ಸಹ ಬಳಸಬೇಕು:

TSTART
Kill ^person(1234567)
ZKill ^index(‘Kamenev’, ‘Sergey’, 1234567)
TCOMMIT

ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಸ್ಥಿರತೆಯ ಅಗತ್ಯವನ್ನು ಪೂರೈಸುವುದು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರೋಗ್ರಾಮರ್ನ ಭುಜದ ಮೇಲೆ ನಿಂತಿದೆ. ಆದರೆ ಗ್ಲೋಬಲ್‌ಗಳ ವಿಷಯಕ್ಕೆ ಬಂದಾಗ, ಅವರ ಕೆಳಮಟ್ಟದ ಸ್ವಭಾವದಿಂದಾಗಿ ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ.

3. ಪ್ರತ್ಯೇಕತೆ

ಇಲ್ಲಿಂದ ಕಾಡುಗಳು ಪ್ರಾರಂಭವಾಗುತ್ತವೆ. ಅನೇಕ ಬಳಕೆದಾರರು ಒಂದೇ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ, ಅದೇ ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸುತ್ತಾರೆ.

ಅನೇಕ ಬಳಕೆದಾರರು ಒಂದೇ ಕೋಡ್ ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಏಕಕಾಲದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಮತ್ತು ಏಕಕಾಲದಲ್ಲಿ ಅನೇಕ ಫೈಲ್‌ಗಳಿಗೆ ಏಕಕಾಲದಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಪರಿಸ್ಥಿತಿಯನ್ನು ಹೋಲಿಸಬಹುದು.

ಡೇಟಾಬೇಸ್ ನೈಜ ಸಮಯದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ವಿಂಗಡಿಸಬೇಕು. ಗಂಭೀರ ಕಂಪನಿಗಳಲ್ಲಿ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣಕ್ಕೆ (ಶಾಖೆಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಲು, ಸಂಘರ್ಷಗಳನ್ನು ಪರಿಹರಿಸಲು, ಇತ್ಯಾದಿ) ಜವಾಬ್ದಾರರಾಗಿರುವ ವಿಶೇಷ ವ್ಯಕ್ತಿಯೂ ಸಹ ಇದ್ದಾರೆ ಮತ್ತು ಡೇಟಾಬೇಸ್ ನೈಜ ಸಮಯದಲ್ಲಿ ಇದೆಲ್ಲವನ್ನೂ ಮಾಡಬೇಕು, ಕಾರ್ಯದ ಸಂಕೀರ್ಣತೆ ಮತ್ತು ಸರಿಯಾಗಿರುವುದು ಡೇಟಾಬೇಸ್ ವಿನ್ಯಾಸ ಮತ್ತು ಅದನ್ನು ಪೂರೈಸುವ ಕೋಡ್.

ಬಳಕೆದಾರರು ಒಂದೇ ಡೇಟಾದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ ಘರ್ಷಣೆಯನ್ನು ತಪ್ಪಿಸಲು ಅವರು ನಿರ್ವಹಿಸಿದ ಕ್ರಿಯೆಗಳ ಅರ್ಥವನ್ನು ಡೇಟಾಬೇಸ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ. ಇದು ಇನ್ನೊಂದಕ್ಕೆ ಘರ್ಷಣೆಯಾಗುವ ಒಂದು ವಹಿವಾಟನ್ನು ಮಾತ್ರ ರದ್ದುಗೊಳಿಸಬಹುದು ಅಥವಾ ಅವುಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

ಮತ್ತೊಂದು ಸಮಸ್ಯೆಯೆಂದರೆ, ವಹಿವಾಟಿನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ (ಬದ್ಧತೆಯ ಮೊದಲು), ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯು ಅಸಮಂಜಸವಾಗಿರಬಹುದು, ಆದ್ದರಿಂದ ಇತರ ವಹಿವಾಟುಗಳು ಡೇಟಾಬೇಸ್‌ನ ಅಸಮಂಜಸ ಸ್ಥಿತಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರದಿರುವುದು ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ, ಇದನ್ನು ಸಂಬಂಧಿತ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ. ಹಲವು ವಿಧಗಳಲ್ಲಿ: ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು, ಬಹು-ಆವೃತ್ತಿಯ ಸಾಲುಗಳು ಮತ್ತು ಇತ್ಯಾದಿ.

ಸಮಾನಾಂತರವಾಗಿ ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ, ಅವರು ಪರಸ್ಪರ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ ಎಂಬುದು ನಮಗೆ ಮುಖ್ಯವಾಗಿದೆ. ಇದು ಪ್ರತ್ಯೇಕತೆಯ ಆಸ್ತಿಯಾಗಿದೆ.

SQL 4 ಪ್ರತ್ಯೇಕತೆಯ ಹಂತಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ:

ಬದ್ಧತೆಯಿಲ್ಲದೆ ಓದಿ
ಓದಲು ಬದ್ಧವಾಗಿದೆ
ಪುನರಾವರ್ತಿತ ಓದುವಿಕೆ
ಧಾರಾವಾಹಿ

ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನೋಡೋಣ. ಪ್ರತಿ ಹಂತವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ವೆಚ್ಚಗಳು ಬಹುತೇಕ ಘಾತೀಯವಾಗಿ ಬೆಳೆಯುತ್ತವೆ.

ಬದ್ಧತೆಯಿಲ್ಲದೆ ಓದಿ - ಇದು ಕಡಿಮೆ ಮಟ್ಟದ ಪ್ರತ್ಯೇಕತೆಯಾಗಿದೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ವೇಗವಾಗಿರುತ್ತದೆ. ವಹಿವಾಟುಗಳು ಪರಸ್ಪರ ಮಾಡಿದ ಬದಲಾವಣೆಗಳನ್ನು ಓದಬಹುದು.

ಓದಲು ಬದ್ಧವಾಗಿದೆ ಪ್ರತ್ಯೇಕತೆಯ ಮುಂದಿನ ಹಂತವಾಗಿದೆ, ಇದು ರಾಜಿಯಾಗಿದೆ. ವಹಿವಾಟುಗಳು ಬದ್ಧತೆಯ ಮೊದಲು ಪರಸ್ಪರರ ಬದಲಾವಣೆಗಳನ್ನು ಓದಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಬದ್ಧತೆಯ ನಂತರ ಮಾಡಿದ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಅವರು ಓದಬಹುದು.

ನಾವು ಸುದೀರ್ಘ ವಹಿವಾಟು T1 ಅನ್ನು ಹೊಂದಿದ್ದರೆ, T2, T3 ... Tn, T1 ಯಂತೆಯೇ ಅದೇ ಡೇಟಾದೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಹಿವಾಟುಗಳಲ್ಲಿ ಬದ್ಧತೆಗಳು ನಡೆದಿವೆ, ನಂತರ T1 ನಲ್ಲಿ ಡೇಟಾವನ್ನು ವಿನಂತಿಸಿದಾಗ ನಾವು ಪ್ರತಿ ಬಾರಿ ವಿಭಿನ್ನ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಈ ವಿದ್ಯಮಾನವನ್ನು ಪುನರಾವರ್ತಿತವಲ್ಲದ ಓದುವಿಕೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಪುನರಾವರ್ತಿತ ಓದುವಿಕೆ — ಈ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟದಲ್ಲಿ ನಾವು ಪುನರಾವರ್ತಿತವಲ್ಲದ ಓದುವಿಕೆಯ ವಿದ್ಯಮಾನವನ್ನು ಹೊಂದಿಲ್ಲ, ಏಕೆಂದರೆ ಡೇಟಾವನ್ನು ಓದಲು ಪ್ರತಿ ವಿನಂತಿಗೆ, ಫಲಿತಾಂಶದ ಡೇಟಾದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದೇ ವಹಿವಾಟಿನಲ್ಲಿ ಮರುಬಳಕೆ ಮಾಡಿದಾಗ, ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ನಿಂದ ಡೇಟಾ ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟದಲ್ಲಿ ಫ್ಯಾಂಟಮ್ ಡೇಟಾವನ್ನು ಓದಲು ಸಾಧ್ಯವಿದೆ. ಸಮಾನಾಂತರ ಬದ್ಧ ವಹಿವಾಟುಗಳಿಂದ ಸೇರಿಸಲಾದ ಹೊಸ ಸಾಲುಗಳನ್ನು ಓದುವುದನ್ನು ಇದು ಸೂಚಿಸುತ್ತದೆ.

ಧಾರಾವಾಹಿ - ಅತ್ಯುನ್ನತ ಮಟ್ಟದ ನಿರೋಧನ. ವಹಿವಾಟಿನಲ್ಲಿ (ಓದುವ ಅಥವಾ ಬದಲಾಯಿಸುವ) ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಬಳಸಲಾದ ಡೇಟಾವು ಮೊದಲ ವಹಿವಾಟು ಪೂರ್ಣಗೊಂಡ ನಂತರವೇ ಇತರ ವಹಿವಾಟುಗಳಿಗೆ ಲಭ್ಯವಾಗುತ್ತದೆ ಎಂಬ ಅಂಶದಿಂದ ಇದು ನಿರೂಪಿಸಲ್ಪಟ್ಟಿದೆ.

ಮೊದಲಿಗೆ, ಮುಖ್ಯ ಥ್ರೆಡ್ನಿಂದ ವಹಿವಾಟಿನಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳ ಪ್ರತ್ಯೇಕತೆ ಇದೆಯೇ ಎಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ. 2 ಟರ್ಮಿನಲ್ ವಿಂಡೋಗಳನ್ನು ತೆರೆಯೋಣ.

Kill ^t

Write ^t(1)
2


TSTART
Set ^t(1)=2

ಯಾವುದೇ ಪ್ರತ್ಯೇಕತೆ ಇಲ್ಲ. ವಹಿವಾಟನ್ನು ತೆರೆದ ಎರಡನೆಯವರು ಏನು ಮಾಡುತ್ತಿದ್ದಾರೆಂದು ಒಂದು ಥ್ರೆಡ್ ನೋಡುತ್ತದೆ.

ವಿಭಿನ್ನ ಥ್ರೆಡ್‌ಗಳ ವಹಿವಾಟುಗಳು ಅವುಗಳೊಳಗೆ ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ನಾವು 2 ಟರ್ಮಿನಲ್ ವಿಂಡೋಗಳನ್ನು ತೆರೆಯೋಣ ಮತ್ತು ಸಮಾನಾಂತರವಾಗಿ 2 ವಹಿವಾಟುಗಳನ್ನು ತೆರೆಯೋಣ.

kill ^t
TSTART
Write ^t(1)
3


TSTART
Set ^t(1)=3

ಸಮಾನಾಂತರ ವಹಿವಾಟುಗಳು ಪರಸ್ಪರರ ಡೇಟಾವನ್ನು ನೋಡುತ್ತವೆ. ಆದ್ದರಿಂದ, ನಾವು ಸರಳವಾದ, ಆದರೆ ವೇಗವಾದ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ, ಬದ್ಧರಾಗಿಲ್ಲ ಓದಿ.

ತಾತ್ವಿಕವಾಗಿ, ಜಾಗತಿಕವಾಗಿ ಇದನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು, ಇದಕ್ಕಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ ಯಾವಾಗಲೂ ಆದ್ಯತೆಯಾಗಿದೆ.

ಜಾಗತಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ನಮಗೆ ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಪ್ರತ್ಯೇಕತೆಯ ಅಗತ್ಯವಿದ್ದರೆ ಏನು?

ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟಗಳು ಏಕೆ ಬೇಕು ಮತ್ತು ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ಇಲ್ಲಿ ನೀವು ಯೋಚಿಸಬೇಕು.

ಅತ್ಯುನ್ನತ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟ, SERIALIZE, ಅಂದರೆ ಸಮಾನಾಂತರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ವಹಿವಾಟುಗಳ ಫಲಿತಾಂಶವು ಅವುಗಳ ಅನುಕ್ರಮ ಮರಣದಂಡನೆಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ಇದು ಘರ್ಷಣೆಗಳ ಅನುಪಸ್ಥಿತಿಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.

ಆಬ್ಜೆಕ್ಟ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಇದನ್ನು ಮಾಡಬಹುದು, ಇದು ಬಹಳಷ್ಟು ವಿಭಿನ್ನ ಉಪಯೋಗಗಳನ್ನು ಹೊಂದಿದೆ: ನೀವು ಆದೇಶದೊಂದಿಗೆ ನಿಯಮಿತ, ಹೆಚ್ಚುತ್ತಿರುವ, ಬಹು ಲಾಕ್ ಮಾಡುವಿಕೆಯನ್ನು ಮಾಡಬಹುದು LOCK.

ಕಡಿಮೆ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟಗಳು ಡೇಟಾಬೇಸ್ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಟ್ರೇಡ್-ಆಫ್ಗಳಾಗಿವೆ.

ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ವಿವಿಧ ಹಂತದ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಹೇಗೆ ಸಾಧಿಸಬಹುದು ಎಂದು ನೋಡೋಣ.

ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ವಿಶೇಷ ಲಾಕ್‌ಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಕೊಳ್ಳಲು ಈ ಆಪರೇಟರ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಹಂಚಿಕೆಯ ಲಾಕ್‌ಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ, ಇದು ಓದುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಇತರ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಬದಲಾಯಿಸದ ಡೇಟಾವನ್ನು ಓದಲು ಅಗತ್ಯವಿರುವಾಗ ಹಲವಾರು ಎಳೆಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

ರಷ್ಯನ್ ಮತ್ತು ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ ಎರಡು-ಹಂತದ ತಡೆಗಟ್ಟುವ ವಿಧಾನದ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ:

→ ಎರಡು ಹಂತದ ತಡೆಗಟ್ಟುವಿಕೆ
→ ಎರಡು ಹಂತದ ಲಾಕಿಂಗ್

ತೊಂದರೆಯೆಂದರೆ ವಹಿವಾಟಿನ ಸಮಯದಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯು ಅಸಮಂಜಸವಾಗಿರಬಹುದು, ಆದರೆ ಈ ಅಸಂಗತ ಡೇಟಾವು ಇತರ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಗೋಚರಿಸುತ್ತದೆ. ಇದನ್ನು ತಪ್ಪಿಸುವುದು ಹೇಗೆ?

ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಿ, ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯು ಸ್ಥಿರವಾಗಿರುವ ಗೋಚರತೆಯ ವಿಂಡೋಗಳನ್ನು ನಾವು ರಚಿಸುತ್ತೇವೆ. ಮತ್ತು ಒಪ್ಪಿದ ರಾಜ್ಯದ ಗೋಚರತೆಯ ಅಂತಹ ಕಿಟಕಿಗಳಿಗೆ ಎಲ್ಲಾ ಪ್ರವೇಶವನ್ನು ಲಾಕ್‌ಗಳಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ.

ಒಂದೇ ಡೇಟಾದಲ್ಲಿ ಹಂಚಿದ ಲಾಕ್‌ಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದು-ಹಲವಾರು ಪ್ರಕ್ರಿಯೆಗಳು ಅವುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಈ ಲಾಕ್‌ಗಳು ಇತರ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ಅಂದರೆ. ಸ್ಥಿರವಾದ ಡೇಟಾಬೇಸ್ ಸ್ಥಿತಿಯ ವಿಂಡೋಗಳನ್ನು ರೂಪಿಸಲು ಅವುಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಡೇಟಾ ಬದಲಾವಣೆಗಳಿಗಾಗಿ ವಿಶೇಷ ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ - ಕೇವಲ ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ಅಂತಹ ಲಾಕ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ವಿಶೇಷ ಲಾಕ್ ಅನ್ನು ಇವರಿಂದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು:

ಡೇಟಾ ಉಚಿತವಾಗಿದ್ದರೆ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆ
ಈ ಡೇಟಾದಲ್ಲಿ ಹಂಚಿದ ಲಾಕ್ ಅನ್ನು ಹೊಂದಿರುವ ಪ್ರಕ್ರಿಯೆ ಮಾತ್ರ ಮತ್ತು ವಿಶೇಷ ಲಾಕ್ ಅನ್ನು ವಿನಂತಿಸಿದ ಮೊದಲನೆಯದು.

ಗೋಚರತೆಯ ವಿಂಡೋ ಕಿರಿದಾದಷ್ಟೂ, ಇತರ ಪ್ರಕ್ರಿಯೆಗಳು ಅದಕ್ಕೆ ಕಾಯಬೇಕಾಗುತ್ತದೆ, ಆದರೆ ಅದರೊಳಗಿನ ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯು ಹೆಚ್ಚು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.

READ_COMMITTED — ಈ ಹಂತದ ಮೂಲತತ್ವವೆಂದರೆ ನಾವು ಇತರ ಥ್ರೆಡ್‌ಗಳಿಂದ ಬದ್ಧವಾದ ಡೇಟಾವನ್ನು ಮಾತ್ರ ನೋಡುತ್ತೇವೆ. ಮತ್ತೊಂದು ವಹಿವಾಟಿನಲ್ಲಿ ಡೇಟಾವನ್ನು ಇನ್ನೂ ಬದ್ಧವಾಗಿಲ್ಲದಿದ್ದರೆ, ನಾವು ಅದರ ಹಳೆಯ ಆವೃತ್ತಿಯನ್ನು ನೋಡುತ್ತೇವೆ.

ಲಾಕ್ ಬಿಡುಗಡೆಯಾಗುವವರೆಗೆ ಕಾಯುವ ಬದಲು ಕೆಲಸವನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸಲು ಇದು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ವಿಶೇಷ ತಂತ್ರಗಳಿಲ್ಲದೆ, IRIS ನಲ್ಲಿನ ಡೇಟಾದ ಹಳೆಯ ಆವೃತ್ತಿಯನ್ನು ನೋಡಲು ನಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಲಾಕ್‌ಗಳೊಂದಿಗೆ ಮಾಡಬೇಕಾಗಿದೆ.

ಅಂತೆಯೇ, ಸ್ಥಿರತೆಯ ಕ್ಷಣಗಳಲ್ಲಿ ಮಾತ್ರ ಡೇಟಾವನ್ನು ಓದಲು ಅನುಮತಿಸಲು ನಾವು ಹಂಚಿದ ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.

ನಾವು ಒಬ್ಬರಿಗೊಬ್ಬರು ಹಣವನ್ನು ವರ್ಗಾಯಿಸುವ ಬಳಕೆದಾರರ ಬೇಸ್ ^ವ್ಯಕ್ತಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ.

ವ್ಯಕ್ತಿ 123 ರಿಂದ ವ್ಯಕ್ತಿ 242 ಗೆ ವರ್ಗಾವಣೆಯ ಕ್ಷಣ:

LOCK +^person(123), +^person(242)
Set ^person(123, amount) = ^person(123, amount) - amount
Set ^person(242, amount) = ^person(242, amount) + amount
LOCK -^person(123), -^person(242)

ಡೆಬಿಟ್ ಮಾಡುವ ಮೊದಲು 123 ವ್ಯಕ್ತಿಯಿಂದ ಹಣದ ಮೊತ್ತವನ್ನು ವಿನಂತಿಸುವ ಕ್ಷಣವು ವಿಶೇಷವಾದ ಬ್ಲಾಕ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು (ಡೀಫಾಲ್ಟ್ ಆಗಿ):

LOCK +^person(123)
Write ^person(123)

ಮತ್ತು ನಿಮ್ಮ ವೈಯಕ್ತಿಕ ಖಾತೆಯಲ್ಲಿ ಖಾತೆಯ ಸ್ಥಿತಿಯನ್ನು ನೀವು ತೋರಿಸಬೇಕಾದರೆ, ನೀವು ಹಂಚಿದ ಲಾಕ್ ಅನ್ನು ಬಳಸಬಹುದು ಅಥವಾ ಅದನ್ನು ಬಳಸಬೇಡಿ:

LOCK +^person(123)#”S”
Write ^person(123)

ಆದಾಗ್ಯೂ, ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಬಹುತೇಕ ತಕ್ಷಣವೇ ನಿರ್ವಹಿಸಲ್ಪಡುತ್ತವೆ ಎಂದು ನಾವು ಭಾವಿಸಿದರೆ (ಗ್ಲೋಬಲ್ಗಳು ಸಂಬಂಧಿತ ಕೋಷ್ಟಕಕ್ಕಿಂತ ಕಡಿಮೆ-ಮಟ್ಟದ ರಚನೆಯಾಗಿದೆ ಎಂದು ನಾನು ನಿಮಗೆ ನೆನಪಿಸುತ್ತೇನೆ), ನಂತರ ಈ ಹಂತದ ಅಗತ್ಯವು ಕಡಿಮೆಯಾಗುತ್ತದೆ.

ಪುನರಾವರ್ತಿತ ಓದುವಿಕೆ - ಈ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟವು ಏಕಕಾಲೀನ ವಹಿವಾಟುಗಳಿಂದ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಡೇಟಾವನ್ನು ಬಹು ಓದಲು ಅನುಮತಿಸುತ್ತದೆ.

ಅಂತೆಯೇ, ನಾವು ಬದಲಾಯಿಸುವ ಡೇಟಾವನ್ನು ಓದಲು ನಾವು ಹಂಚಿಕೆಯ ಲಾಕ್ ಅನ್ನು ಹಾಕಬೇಕು ಮತ್ತು ನಾವು ಬದಲಾಯಿಸುವ ಡೇಟಾದ ಮೇಲೆ ವಿಶೇಷ ಲಾಕ್‌ಗಳನ್ನು ಹಾಕಬೇಕಾಗುತ್ತದೆ.

ಅದೃಷ್ಟವಶಾತ್, LOCK ಆಪರೇಟರ್ ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಲಾಕ್‌ಗಳನ್ನು ವಿವರವಾಗಿ ಪಟ್ಟಿ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಅದರಲ್ಲಿ ಒಂದು ಹೇಳಿಕೆಯಲ್ಲಿ ಬಹಳಷ್ಟು ಇರಬಹುದು.

LOCK +^person(123, amount)#”S”
чтение ^person(123, amount)

ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳು (ಈ ಸಮಯದಲ್ಲಿ ಸಮಾನಾಂತರ ಎಳೆಗಳು ^ವ್ಯಕ್ತಿಯನ್ನು (123, ಮೊತ್ತ) ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತವೆ, ಆದರೆ ಸಾಧ್ಯವಿಲ್ಲ)

LOCK +^person(123, amount)
изменение ^person(123, amount)
LOCK -^person(123, amount)

чтение ^person(123, amount)
LOCK -^person(123, amount)#”S”

ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಲಾದ ಲಾಕ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವಾಗ, ಅವುಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ, ಆದರೆ ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ:

LOCK +(^person(123),^person(242))

ನಂತರ ಅವುಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪರಮಾಣುವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ.

ಸೀರಿಯಲೈಜ್ — ನಾವು ಲಾಕ್‌ಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಅಂತಿಮವಾಗಿ ಸಾಮಾನ್ಯ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ವಹಿವಾಟುಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನಕ್ಕಾಗಿ, ಹೆಚ್ಚಿನ ಲಾಕ್‌ಗಳು ವಿಶೇಷವಾಗಿರಬೇಕು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಜಾಗತಿಕ ಸಣ್ಣ ಪ್ರದೇಶಗಳಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಬೇಕು.

ನಾವು ಜಾಗತಿಕ ^ವ್ಯಕ್ತಿಯಲ್ಲಿ ಹಣವನ್ನು ಡೆಬಿಟ್ ಮಾಡುವ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, SERIALIZE ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟ ಮಾತ್ರ ಅದಕ್ಕೆ ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದೆ, ಏಕೆಂದರೆ ಹಣವನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅನುಕ್ರಮವಾಗಿ ಖರ್ಚು ಮಾಡಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಅದೇ ಮೊತ್ತವನ್ನು ಹಲವಾರು ಬಾರಿ ಖರ್ಚು ಮಾಡಲು ಸಾಧ್ಯವಿದೆ.

4. ಬಾಳಿಕೆ

ನಾನು ಬಳಸಿ ಧಾರಕವನ್ನು ಕಠಿಣವಾಗಿ ಕತ್ತರಿಸುವುದರೊಂದಿಗೆ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಿದೆ

docker kill my-iris

ಬೇಸ್ ಅವರನ್ನು ಚೆನ್ನಾಗಿ ಸಹಿಸಿಕೊಂಡಿದೆ. ಯಾವುದೇ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲಾಗಿಲ್ಲ.

ತೀರ್ಮಾನಕ್ಕೆ

ಗ್ಲೋಬಲ್‌ಗಳಿಗಾಗಿ, ಇಂಟರ್‌ಸಿಸ್ಟಮ್ಸ್ IRIS ವಹಿವಾಟು ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ. ಅವು ನಿಜವಾಗಿಯೂ ಪರಮಾಣು ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿವೆ. ಗ್ಲೋಬಲ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಪ್ರೋಗ್ರಾಮರ್ ಪ್ರಯತ್ನಗಳು ಮತ್ತು ವಹಿವಾಟುಗಳ ಬಳಕೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ವಿದೇಶಿ ಕೀಗಳಂತಹ ಸಂಕೀರ್ಣ ಅಂತರ್ನಿರ್ಮಿತ ರಚನೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

ಲಾಕ್‌ಗಳನ್ನು ಬಳಸದೆಯೇ ಗ್ಲೋಬಲ್‌ಗಳ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟವು ರೀಡ್ ಅನ್‌ಕಮಿಟೆಡ್ ಆಗಿದೆ ಮತ್ತು ಲಾಕ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಅದನ್ನು SERIALIZE ಹಂತದವರೆಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಜಾಗತಿಕ ವಹಿವಾಟಿನ ನಿಖರತೆ ಮತ್ತು ವೇಗವು ಪ್ರೋಗ್ರಾಮರ್‌ನ ಕೌಶಲ್ಯವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ: ಓದುವಾಗ ಹೆಚ್ಚು ವ್ಯಾಪಕವಾಗಿ ಹಂಚಿಕೆಯಾದ ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಪ್ರತ್ಯೇಕತೆ ಮತ್ತು ಹೆಚ್ಚು ಕಿರಿದಾದ ವಿಶೇಷ ಲಾಕ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ, ಕಾರ್ಯಕ್ಷಮತೆ ವೇಗವಾಗಿರುತ್ತದೆ.

ಮೂಲ: www.habr.com