'සමමුහුර්ත' යන්නෙන් අදහස් කරන්නේ කුමක්ද?

synchronizedමූල පදය භාවිතා කිරීම සහ වැදගත්කම පිළිබඳව මට ප්‍රශ්න කිහිපයක් තිබේ .

• synchronizedමූල පදයේ වැදගත්කම කුමක්ද?
• ක්‍රම විය යුත්තේ synchronizedකවදාද?
• ක්‍රමලේඛන හා තර්කානුකූලව එයින් අදහස් කරන්නේ කුමක්ද?

මෙම synchronizedමූල පදය වෙනස් නූල් ගැන සියලු ම විචල්ය, වස්තූන් හා සම්පත් සහ කියවීම් සහ ලිවීම් වේ. මෙය ජාවා හි සුළු මාතෘකාවක් නොවේ, නමුත් මෙන්න සූර්යයා උපුටා දැක්වීමකි:

synchronized ක්‍රම මඟින් නූල් ඇඟිලි ගැසීම් සහ මතක අනුකූලතා දෝෂ වැළැක්වීම සඳහා සරල උපාය මාර්ගයක් සක්‍රීය කරයි: වස්තුවක් එකකට වඩා වැඩි ගණනකට දෘශ්‍යමාන වේ නම්, සියල්ලම කියවීම හෝ ලිවීම එම වස්තුවේ විචල්‍යයන් සමමුහුර්ත ක්‍රම මඟින් සිදු කරයි.

ඉතා කෙටියෙන් කිවහොත්: ඔබට එකම 'සම්පතකට' කියවන හා ලියන නූල් දෙකක් ඇති විට, නම් කරන ලද විචල්‍යයක් කියන්න foo, මෙම නූල් විචල්‍යයට පරමාණුක ආකාරයෙන් ප්‍රවේශ වන බව සහතික කළ යුතුය. synchronizedමූල පදය නොමැතිව , ඔබේ නූල් 1 ට වෙනස් කළ නූල් 2 නොපෙනේfoo , හෝ ඊට වඩා නරක නම්, එය අඩක් පමණක් වෙනස් කළ හැකිය. මෙය ඔබ තර්කානුකූලව අපේක්ෂා කරන දෙයක් නොවේ.

නැවතත්, මෙය ජාවා හි සුළු නොවන මාතෘකාවකි. වැඩිදුර දැන ගැනීම සඳහා, SO සහ Interwebs හි මාතෘකා ගවේෂණය කරන්න:

• සමගාමී මුදල්
• ජාවා මතක ආකෘතිය

"බ්‍රයන් ගොට්ස්" යන නම ඔබේ මොළයේ ඇති "සමගාමී" යන යෙදුම සමඟ ස්ථිරවම සම්බන්ධ වන තුරු මෙම මාතෘකා ගවේෂණය කරන්න.

හොඳයි, මම හිතන්නේ අපට ප්‍රමාණවත් න්‍යායාත්මක පැහැදිලි කිරීම් ඇති බැවින් මෙම කේතය සලකා බලන්න

public class SOP {
    public static void print(String s) {
        System.out.println(s+"\n");
    }
}

public class TestThread extends Thread {
    String name;
    TheDemo theDemo;
    public TestThread(String name,TheDemo theDemo) {
        this.theDemo = theDemo;
        this.name = name;
        start();
    }
    @Override
    public void run() {
        theDemo.test(name);
    }
}

public class TheDemo {
    public synchronized void test(String name) {
        for(int i=0;i<10;i++) {
            SOP.print(name + " :: "+i);
            try{
                Thread.sleep(500);
            } catch (Exception e) {
                SOP.print(e.getMessage());
            }
        }
    }
    public static void main(String[] args) {
        TheDemo theDemo = new TheDemo();
        new TestThread("THREAD 1",theDemo);
        new TestThread("THREAD 2",theDemo);
        new TestThread("THREAD 3",theDemo);
    }
}

සටහන: synchronizedපෙර නූල් ක්‍රියාත්මක කිරීම අවසන් නොවන තාක් කල් ඊළඟ ත්‍රෙඩ් එකේ ක්‍රමවේදය පරීක්‍ෂණයට අවහිර කරයි. නූල් වලට වරකට මෙම ක්‍රමයට ප්‍රවේශ විය හැකිය. තොරවsynchronizedසියලුම නූල් එකවර මෙම ක්‍රමයට ප්‍රවේශ විය හැකිය.

නූලක් වස්තුවේ සමමුහුර්ත ක්‍රමවේදය 'පරීක්ෂණය' ලෙස හැඳින්වූ විට (මෙහි වස්තුව 'TheDemo' පන්තියේ නිදසුනකි) එය එම වස්තුවේ අගුල ලබා ගනී, ඕනෑම නව නූලකට පෙර නූල් පවතින තාක් කල් එකම වස්තුවක සමමුහුර්ත ක්‍රමයක් හැඳින්විය නොහැක. අගුල අත්පත් කර ගත් අගුල නිදහස් නොකරයි.

පංතියේ ඕනෑම ස්ථිතික සමමුහුර්ත ක්‍රමයක් හැඳින්වූ විට සමාන දෙයක් සිදු වේ. නූල් පන්තිය හා සම්බන්ධ අගුල ලබා ගනී (මේ අවස්ථාවේ දී එම පන්තියේ නිදසුනක් සඳහා ස්ථිතික නොවන සමමුහුර්ත නොවන ඕනෑම ක්‍රමයක් ඕනෑම නූල් එකකින් හැඳින්විය හැකිය, මන්ද එම වස්තු මට්ටමේ අගුල තවමත් පවතින බැවිනි). දැනට අගුල තබා ඇති නූල් මඟින් පන්ති මට්ටමේ අගුල මුදා නොහරින තාක් වෙනත් කිසිදු නූලකට පන්තියේ ස්ථිතික සමමුහුර්ත ක්‍රමයක් ඇමතීමට නොහැකි වනු ඇත.

සමමුහුර්තකරණය සමඟ ප්‍රතිදානය

THREAD 1 :: 0
THREAD 1 :: 1
THREAD 1 :: 2
THREAD 1 :: 3
THREAD 1 :: 4
THREAD 1 :: 5
THREAD 1 :: 6
THREAD 1 :: 7
THREAD 1 :: 8
THREAD 1 :: 9
THREAD 3 :: 0
THREAD 3 :: 1
THREAD 3 :: 2
THREAD 3 :: 3
THREAD 3 :: 4
THREAD 3 :: 5
THREAD 3 :: 6
THREAD 3 :: 7
THREAD 3 :: 8
THREAD 3 :: 9
THREAD 2 :: 0
THREAD 2 :: 1
THREAD 2 :: 2
THREAD 2 :: 3
THREAD 2 :: 4
THREAD 2 :: 5
THREAD 2 :: 6
THREAD 2 :: 7
THREAD 2 :: 8
THREAD 2 :: 9

සමමුහුර්ත කිරීමකින් තොරව ප්‍රතිදානය

THREAD 1 :: 0
THREAD 2 :: 0
THREAD 3 :: 0
THREAD 1 :: 1
THREAD 2 :: 1
THREAD 3 :: 1
THREAD 1 :: 2
THREAD 2 :: 2
THREAD 3 :: 2
THREAD 1 :: 3
THREAD 2 :: 3
THREAD 3 :: 3
THREAD 1 :: 4
THREAD 2 :: 4
THREAD 3 :: 4
THREAD 1 :: 5
THREAD 2 :: 5
THREAD 3 :: 5
THREAD 1 :: 6
THREAD 2 :: 6
THREAD 3 :: 6
THREAD 1 :: 7
THREAD 2 :: 7
THREAD 3 :: 7
THREAD 1 :: 8
THREAD 2 :: 8
THREAD 3 :: 8
THREAD 1 :: 9
THREAD 2 :: 9
THREAD 3 :: 9

මෙම synchronizedමූල පදය බහු නූල් විසින් කේතය හෝ වස්තුවක වාරණ සමගාමීව ප්රවේශ වීම වළක්වයි. සියළුම ක්‍රම Hashtableවේ synchronized, එබැවින් වරකට ඒවා ක්‍රියාත්මක කළ හැක්කේ එක් නූල් එකකට පමණි.

synchronizedවැනි නොවන ඉදිකිරීම් භාවිතා කරන විට HashMap, අනුකූලතා දෝෂ වැළැක්වීම සඳහා ඔබේ කේතයේ නූල්-ආරක්‍ෂිත අංග ගොඩනගා ගත යුතුය.

synchronizedබහු නූල් සහිත පරිසරයක, synchronizedක්‍රමයක් (ය) / බ්ලොක් (ය) ඇති වස්තුවක් synchronizedඑකවර කේත ක්‍රමයට (ය) / වාරණ (ය) වෙත ප්‍රවේශ වීමට නූල් දෙකකට ඉඩ නොදේ . මෙයින් අදහස් කරන්නේ එක් නූල් එකක් කියවිය නොහැකි අතර තවත් නූල් යාවත්කාලීන කරන බවයි.

දෙවන නූල් ඒ වෙනුවට පළමු නූල් ක්‍රියාත්මක වන තෙක් බලා සිටිනු ඇත. පොදු කාර්ය වේගය වේගය, නමුත් වාසිය දත්තවල අනුකූලතාව සහතික කරයි.

ඔබේ යෙදුම තනි නූල් නම්, synchronizedබ්ලොක් මඟින් ප්‍රතිලාභ ලබා නොදේ.

මෙම synchronizedඉඟි පද, එකම එක නූල් ක්රමය එම අවස්ථාවේ දී (දී ඇති වස්තුව උදාහරණයකට කියනවා නම්, ස්ථිතික ක්රමය වේ නම්) ක්රියාත්මක කළ හැකි නිසා බව ක්රමය ඇතුළු විට නූල් අගුලු ලබා ගැනීම සඳහා හේතු වේ.

මෙය නිතරම හැඳින්වෙන්නේ පංතියේ නූල්-ආරක්ෂිත කිරීම, නමුත් මම කියන්නේ මෙය සුහද කතාබහක් බවයි. සමමුහුර්තකරණය මගින් දෛශිකයේ අභ්‍යන්තර තත්වය දූෂිත නොවී ආරක්ෂා වන බව සත්‍යයක් වුවද, මෙය සාමාන්‍යයෙන් දෛශික පරිශීලකයාට බොහෝ සෙයින් උපකාරී නොවේ.

මෙය සලකා බලන්න:

 if (vector.isEmpty()){
     vector.add(data);
 }

සම්බන්ධ වූ ක්‍රම සමමුහුර්ත කර ඇතත්, ඒවා තනි තනිව අගුළු දමා අගුළු ඇරීම නිසා, අවාසනාවකට කාලානුරූපී නූල් දෙකකට මූලද්‍රව්‍ය දෙකක් සහිත දෛශිකයක් නිර්මාණය කළ හැකිය.

එබැවින්, ඔබගේ යෙදුම් කේතය තුළද සමමුහුර්ත කළ යුතුය.

ක්‍රම-මට්ටමේ සමමුහුර්තකරණය අ) ඔබට අවශ්‍ය නොවන විට මිල අධික වන අතර ආ) ඔබට සමමුහුර්තකරණය අවශ්‍ය වූ විට ප්‍රමාණවත් නොවූ හෙයින්, දැන් සමමුහුර්ත නොකළ ප්‍රතිස්ථාපන ඇත (දෛශිකයේ අරා ලැයිස්තු).

වඩාත් මෑතකදී, සමගාමී මුදල් පැකේජය නිකුත් කර ඇති අතර, බහු නූල් ගැටලු පිළිබඳව සැලකිලිමත් වන දක්ෂ උපයෝගීතා ගණනාවක් ඇත.

දළ විශ්ලේෂණය

ජාවා හි සමමුහුර්ත යතුරුපදය නූල්-ආරක්ෂාව සමඟ සම්බන්ධ වේ, එනම්, බහු නූල් එකම විචල්‍යය කියවන විට හෝ ලිවීමේදී.
මෙය සෘජුවම (එකම විචල්‍යයට ප්‍රවේශ වීමෙන්) හෝ වක්‍රව (එකම විචල්‍යයට ප්‍රවේශ වන වෙනත් පන්තියක් භාවිතා කරන පන්තියක් භාවිතා කිරීමෙන්) සිදුවිය හැකිය.

එකම විචල්‍යයට ආරක්ෂිත ආකාරයකින් බහු නූල් වලට ප්‍රවේශ විය හැකි කේත සමූහයක් අර්ථ දැක්වීමට සමමුහුර්ත යතුරු පදය භාවිතා කරයි.

ගැඹුරු

සින්ටැක්ස් ප්‍ර wise ාවෙන් synchronizedයතුරු පදය Objectඑහි පරාමිතිය ලෙස ( අගුළු වස්තුවක් ලෙස හැඳින්වේ ) ගන්නා අතර එය පසුව a { block of code }.

• ක්‍රියාත්මක කිරීමේදී මෙම මූල පදය හමු වූ විට, වත්මන් නූල් උත්සාහ කරන්නේ අගුළු වස්තුව "අගුළු / අත්පත් කර ගැනීමට / අයිති කර ගැනීමට" (ඔබේ තේරීම ගන්න) සහ අගුල අත්පත් කර ගැනීමෙන් පසුව සම්බන්ධිත කේත කොටස ක්‍රියාත්මක කිරීමට ය.

• සමමුහුර්ත කේත බ්ලොක් තුළ ඇති විචල්‍යයන් සඳහා වන ඕනෑම ලිවීමක් එකම අගුළු වස්තුවක් භාවිතා කරමින් සමමුහුර්ත කේත බ්ලොක් තුළ කේතය ක්‍රියාත්මක කරන අනෙක් සෑම නූලකටම දෘශ්‍යමාන වන බවට සහතික වේ .

• වරකට එක් නූල් එකකට පමණක් අගුල රඳවා තබා ගත හැකි අතර, එම කාලය තුළ එකම අගුළු වස්තුවක් ලබා ගැනීමට උත්සාහ කරන අනෙක් සියලුම නූල් රැඳී සිටිනු ඇත (ඒවා ක්‍රියාත්මක කිරීම නවතා දමන්න ). ක්‍රියාත්මක කිරීම සමමුහුර්ත කේත කොටසෙන් පිටවන විට අගුල මුදා හරිනු ඇත.

සමමුහුර්ත ක්‍රම:

එකතු synchronizedක්රමයක් නිර්වචනය මූල පදය සමග ද සමමුහුර්ත කේතය වාරණ ඔතා කරමින් සමස්ත ක්රමය ශරීරය සමාන වේ අගුලු වස්තුව වීම this (උදාහරණයක් ක්රම සඳහා) සහ ClassInQuestion.getClass() (පන්ති ක්රම සඳහා) .

- උදාහරණ ක්‍රමය යනු staticමූලපදය නොමැති ක්‍රමයකි .
- පන්ති ක්‍රමය යනු ඇති ක්‍රමයකිstatic මූලපදය .

කාර්මික

සමමුහුර්තකරණයකින් තොරව, කියවීම සහ ලිවීම සිදුවන්නේ කුමන අනුපිළිවෙලට දැයි සහතික නොවේ, සමහර විට විචල්‍යය කුණු කසළ සමඟ ඉතිරි වේ.
(නිදසුනක් ලෙස විචල්‍යයකට එක් නූල් එකකින් ලියන ලද බිටු වලින් අඩක් සහ තවත් නූල් වලින් ලියන ලද බිටු වලින් අඩක් අවසන් විය හැකි අතර, විචල්‍යය නූල් දෙකම ලිවීමට උත්සාහ නොකළ තත්වයට පත්වේ, නමුත් දෙකම ඒකාබද්ධ අවුලකි.)

(තාප්ප-ඔරලෝසු වේලාවට පෙර) ත්‍රෙඩ් එකක ලිවීමේ මෙහෙයුමක් සම්පූර්ණ කිරීම පමණක් ප්‍රමාණවත් නොවේ, මන්ද දෘඩාංග මඟින් විචල්‍යයේ අගය හැඹිලිගත කළ හැකි වූ අතර කියවීමේ නූලට ලියා ඇති දේ වෙනුවට හැඹිලි අගය පෙනෙනු ඇත. එය.

නිගමනය

මේ අනුව ජාවා නඩුවේදී, නූල් දෝෂ සිදු නොවීමට වග බලා ගැනීම සඳහා ඔබ ජාවා මතක ආකෘතිය අනුගමනය කළ යුතුය.
වෙනත් වචන වලින් කිවහොත්: සමමුහුර්තකරණය, පරමාණුක මෙහෙයුම් හෝ පංති භාවිතා කරන්න.

මුලාශ්‍ර

http://docs.oracle.com/javase/specs/jls/se8/html/index.html
Java® භාෂා පිරිවිතර, 2015-02-13

එය පාපන්දු පිටියක ඔබට හමුවිය හැකි ආකාරයේ හැරවුම් ලක්ෂ්‍යයක් ලෙස සිතන්න. ඇතුළට යාමට කැමති මිනිසුන්ගේ සමාන්තර වාෂ්ප ඇත, නමුත් හැරවුම් අවස්ථාවේ දී ඒවා 'සමමුහුර්ත' වේ. වරකට එක් පුද්ගලයෙකුට පමණක් පිවිසිය හැකිය. ඒ හරහා යාමට කැමති සියල්ලන්ම එසේ කරනු ඇත, නමුත් ඔවුන්ට ඒ හරහා යාමට හැකි වන තෙක් බලා සිටීමට සිදුවනු ඇත.

සමමුහුර්ත යතුරු පදය කුමක්ද?

නූල් සන්නිවේදනය කරන්නේ මූලික වශයෙන් ක්ෂේත්‍ර වෙත ප්‍රවේශය බෙදා ගැනීම සහ වස්තු යොමු ක්ෂේත්‍ර යොමු කිරීමෙනි. මෙම ආකාරයේ සන්නිවේදනය අතිශයින්ම කාර්යක්ෂම වන නමුත් දෝෂ දෙකක් ඇති කළ හැකිය: නූල් ඇඟිලි ගැසීම් සහ මතක අනුකූලතා දෝෂ . මෙම දෝෂ වැළැක්වීම සඳහා අවශ්‍ය මෙවලම සමමුහුර්තකරණයයි.

සමමුහුර්ත කුට්ටි හෝ ක්‍රම මඟින් නූල් ඇඟිලි ගැසීම් වලක්වන අතර දත්ත ස්ථාවර බව සහතික කරගන්න. ඕනෑම වේලාවක, අගුලක් ලබා ගැනීමෙන් සමමුහුර්ත කොටුවකට හෝ ක්‍රමයකට ( විවේචනාත්මක අංශයට ) පිවිසිය හැක්කේ එක් නූල් එකකට පමණි . විවේචනාත්මක අංශයට ප්‍රවේශ වීම සඳහා අගුල මුදා හැරීමට වෙනත් නූල් (ය) බලා සිටිනු ඇත .

ක්‍රම සමමුහුර්ත කරන්නේ කවදාද?

ඔබ synchronizedක්‍රම නිර්වචනයට හෝ ප්‍රකාශනයට එකතු කරන විට ක්‍රම සමමුහුර්ත වේ. ඔබට ක්‍රමයක් සමඟ විශේෂිත කේත සමූහයක් සමමුහුර්ත කළ හැකිය.

ගැති ව්‍යාකරණ හා තර්කානුකූලව අදහස් කරන්නේ කුමක්ද?

අගුලක් ලබා ගැනීමෙන් විවේචනාත්මක අංශයට ප්‍රවේශ විය හැක්කේ එක් නූල් එකකට පමණක් බව එයින් අදහස් වේ. මෙම නූලෙන් මෙම අගුල මුදා හරිනු නොලැබේ නම්, අනෙක් සියලුම නූල් (ය) අගුලක් ලබා ගැනීමට බලා සිටිය යුතුය. පිටතට යාමේ අගුල සමඟ විවේචනාත්මක අංශයට ඇතුළු වීමට ඔවුන්ට ප්‍රවේශය නොමැත .

මෙය මැජික් එකකින් කළ නොහැක. යෙදුමේ තීරණාත්මක අංශ (ය) හඳුනාගෙන ඒ අනුව එය ආරක්ෂා කිරීම ක්‍රමලේඛක වගකීමකි . ඔබේ යෙදුම ආරක්ෂා කිරීම සඳහා ජාවා රාමුවක් සපයයි, නමුත් ආරක්ෂා කළ යුතු සියලුම අංශ කොතැනද සහ කුමක් ද යන්න ක්‍රමලේඛකයාගේ වගකීම වේ.

වැඩි විස්තර ජාවා ප්‍රලේඛන පිටුවෙන්

අභ්‍යන්තර අගුල් සහ සමමුහුර්තකරණය:

සමමුහුර්තකරණය අභ්‍යන්තර අගුලක් හෝ මොනිටර අගුලක් ලෙස හැඳින්වෙන අභ්‍යන්තර ආයතනයක් වටා ගොඩනගා ඇත. සමමුහුර්තකරණයේ අංශ දෙකෙහිම අභ්‍යන්තර අගුල් කාර්යභාරයක් ඉටු කරයි: වස්තුවක තත්වයට පමණක් ප්‍රවේශ වීම බලාත්මක කිරීම සහ දෘශ්‍යතාවයට අත්‍යවශ්‍ය වන සම්බන්ධතා ඇතිවීමට පෙර.

සෑම වස්තුවකටම ආවේනික අගුලක් ඇත . සම්මුතිය අනුව, වස්තුවක ක්ෂේත්‍රයට සුවිශේෂී හා ස්ථාවර ප්‍රවේශයක් අවශ්‍ය වන නූලකට ඒවාට ප්‍රවේශ වීමට පෙර වස්තුවෙහි අභ්‍යන්තර අගුල ලබා ගත යුතු අතර, ඒවා සිදු වූ විට සහජ අගුල මුදා හරිනු ඇත.

නූල් අගුල අත්පත් කර ගෙන අගුල මුදා හරින කාලය අතර අභ්‍යන්තර අගුල අයිති බව කියනු ලැබේ. නූලකට අභ්‍යන්තර අගුලක් ඇති තාක් කල්, වෙනත් කිසිදු නූලකට එකම අගුල ලබා ගත නොහැක. අගුල ලබා ගැනීමට උත්සාහ කරන විට අනෙක් නූල් අවහිර වනු ඇත.

නූලක් සහජ අගුලක් මුදා හරින විට, එම ක්‍රියාව සහ එකම අගුල අත්පත් කර ගැනීම අතර සිදුවීමට පෙර සම්බන්ධතාවයක් ඇති වේ.

ක්‍රම සමමුහුර්ත කිරීම බලපෑම් දෙකක් ඇත :

පළමුවෙන්ම, එකම වස්තුවක් මත සමමුහුර්ත ක්‍රම දෙකක ආයාචනා දෙකක් එකිනෙකට සම්බන්ධ කළ නොහැක.

එක් නූලක් වස්තුවක් සඳහා සමමුහුර්ත ක්‍රමයක් ක්‍රියාත්මක කරන විට, පළමු නූල් වස්තුව සමඟ සිදු කරන තුරු එකම වස්තු වාරණය සඳහා (ක්‍රියාත්මක කිරීම අත්හිටුවීම) සඳහා සමමුහුර්ත ක්‍රම භාවිතා කරන අනෙක් සියලුම නූල්.

දෙවනුව, සමමුහුර්ත ක්‍රමයක් පිටවන විට, එය ස්වයංක්‍රීයව එකම වස්තුවක් සඳහා සමමුහුර්ත ක්‍රමවේදයක් ඉල්ලා සිටීමෙන් පසුව සිදුවීමට පෙර සම්බන්ධතාවයක් ඇති කරයි.

වස්තුවේ තත්වයට සිදුවන වෙනස්කම් සියලු නූල් වලට පෙනෙන බව මෙය සහතික කරයි.

සමමුහුර්තකරණය සඳහා වෙනත් විකල්ප සොයන්න:

ජාවා හි සමමුහුර්ත (මෙය) වළක්වා ගන්න?

Synchronized normal methodසමාන Synchronized statement(මෙය භාවිතා කරන්න)

class A {
    public synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(this) {
             // all function code
        }
    } 
}

Synchronized static methodසමාන Synchronized statement(පන්තිය භාවිතා කරන්න)

class A {
    public static synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(A.class) {
             // all function code
        }
    } 
}

සමමුහුර්ත ප්‍රකාශය (විචල්‍යය භාවිතා කරමින්)

class A {
    private Object lock1 = new Object();

    public void methodA() {
        synchronized(lock1 ) {
             // all function code
        }
    } 
}

සඳහා synchronized, අප යන දෙදෙනාම Synchronized Methodsහා Synchronized Statements. කෙසේ වෙතත්, Synchronized Methodsසමාන වන Synchronized Statementsබැවින් අප තේරුම් ගත යුතුය Synchronized Statements.

=> මූලික වශයෙන්, අපට ඇත

synchronized(object or class) { // object/class use to provides the intrinsic lock
   // code 
}

අවබෝධ කර ගැනීමට උපකාරී වන 2 සිතුවිලි මෙන්න synchronized

• සෑම වස්තුවකට / පන්තියකටම ඒ හා intrinsic lockසම්බන්ධ වේ.
• නූලක් a ට ආයාචනා කළ විට synchronized statement, එය ස්වයංක්‍රීයව intrinsic lockඑම synchronized statement'sවස්තුව සඳහා වන අතර ක්‍රමය නැවත පැමිණි විට එය මුදා හරිනු ඇත. නූල් එකක් සතුව ඇති තාක් කල් intrinsic lock, වෙනත් කිසිදු නූලකට SAME lock => නූල් ආරක්ෂිතව ලබා ගත නොහැක.

=> thread Aආයාචනා කරන විට synchronized(this){// code 1}=> ඇති සියලුම බ්ලොක් කේතය (පන්තිය ඇතුළත) ඇති synchronized(this)අතර සියල්ලම synchronized normal method(පන්තියේ ඇතුළත) අගුළු දමා ඇත්තේ එකම අගුල නිසාය . එය thread Aඅගුළු ඇරීමෙන් පසු ක්‍රියාත්මක වේ ("// කේතය 1" අවසන්).

මෙම හැසිරීම සමාන synchronized(a variable){// code 1}හෝ හෝ synchronized(class)වේ.

SAME LOCK => අගුල (කුමන ක්‍රමය මත රඳා නොපවතීද? නැතහොත් කුමන ප්‍රකාශද?)

සමමුහුර්ත ක්‍රමයක් හෝ සමමුහුර්ත ප්‍රකාශ භාවිතා කරන්නද?

මම වඩාත් කැමති synchronized statementsඑය වඩා දිගු කළ හැකි බැවිනි. උදාහරණය, ​​අනාගතයේදී, ඔබට අවශ්‍ය වන්නේ ක්‍රමයේ කොටසක් සමමුහුර්ත කිරීම පමණි. උදාහරණයක් ලෙස, ඔබට සමමුහුර්ත ක්‍රම 2 ක් ඇති අතර එයට එකිනෙකට අදාළ කිසිවක් නොමැත , කෙසේ වෙතත් නූල් ක්‍රමයක් ක්‍රියාත්මක කරන විට එය අනෙක් ක්‍රමය අවහිර කරනු ඇත (එය භාවිතයෙන් වළක්වා ගත හැකිය synchronized(a variable)).

කෙසේ වෙතත්, අයදුම් කරන්න සමමුහුර්ත ක්‍රමය සරල වන අතර කේතය සරල ලෙස පෙනේ. සමහර පංති සඳහා, ඇත්තේ සමමුහුර්ත ක්‍රම 1 ක් පමණි, නැතහොත් පන්තියේ ඇති සියලුම සමමුහුර්ත ක්‍රම එකිනෙකට අදාළ වේ => අපට synchronized methodකේතය කෙටි කිරීමට සහ තේරුම් ගැනීමට පහසුය

සටහන

(එය බොහෝ දේට අදාළ නොවේ synchronized, එය වස්තුව සහ පන්තිය අතර වෙනස හෝ කිසිවක් ස්ථිතික හා ස්ථිතික නොවේ).

• ඔබ භාවිතා කරන විට synchronizedහෝ සාමාන්‍ය ක්‍රමයක් synchronized(this)හෝsynchronized(non-static variable) එහි එක් එක් වස්තුව උදාහරණයක් මත පදනම සමමුහුර්ත වනු ඇත.
• ඔබ භාවිතා කරන විට synchronizedහෝ ස්ථිතික ක්‍රමයක් synchronized(class)හෝ synchronized(static variable)එය පන්තියේ පදනම සමමුහුර්ත කරයි

යොමුව

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html

එය උපකාරී වේ යැයි සිතමි

මෙන්න ජාවා නිබන්ධන වලින් පැහැදිලි කිරීමක් .

පහත කේතය සලකා බලන්න:

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

නම් countක උදාහරණයක් වේ SynchronizedCounter, සමමුහුර්තකරණය මෙම ක්රම බලපෑම් දෙකක් ඇත:

• පළමුවෙන්ම, එකම වස්තුවක් මත සමමුහුර්ත ක්‍රම දෙකක ආයාචනා දෙකක් එකිනෙකට සම්බන්ධ කළ නොහැක. එක් නූලක් වස්තුවක් සඳහා සමමුහුර්ත ක්‍රමයක් ක්‍රියාත්මක කරන විට, පළමු නූල් වස්තුව සමඟ සිදු කරන තුරු එකම වස්තු වාරණය සඳහා (ක්‍රියාත්මක කිරීම අත්හිටුවීම) සඳහා සමමුහුර්ත ක්‍රම භාවිතා කරන අනෙක් සියලුම නූල්.
• දෙවනුව, සමමුහුර්ත ක්‍රමයක් පිටවන විට, එය ස්වයංක්‍රීයව එකම වස්තුවක් සඳහා සමමුහුර්ත ක්‍රමවේදයක් ඉල්ලා සිටීමෙන් පසුව සිදුවීමට පෙර සම්බන්ධතාවයක් ඇති කරයි. වස්තුවේ තත්වයට සිදුවන වෙනස්කම් සියලු නූල් වලට පෙනෙන බව මෙය සහතික කරයි.

සමමුහුර්ත කර ඇති මගේ අවබෝධයට මූලික වශයෙන් අදහස් කරන්නේ සම්පාදකයා ඔබේ ක්‍රමය වටා මොනිටර්.එන්ටර් සහ මොනිටරය ලිවීමයි. එනිසා එය භාවිතා කරන ආකාරය අනුව එය නූල් ආරක්ෂිත විය හැකිය (මා අදහස් කරන්නේ ඔබේ පන්තිය කරන දේ අනුව නූල් ආරක්ෂිත නොවන සමමුහුර්ත ක්‍රම සහිත වස්තුවක් ඔබට ලිවිය හැකිය).

අනෙක් පිළිතුරු නැති දේ එක් වැදගත් අංගයකි: මතක බාධක . නූල් සමමුහුර්ත මූලික වශයෙන් සමන්විත දෙකක් : අනුක්‍රමිකකරණය සහ දෘශ්‍යතාව. "Jvm මතක බාධකයක්" සඳහා ගූගල් කිරීමට මම සෑම කෙනෙකුටම උපදෙස් දෙමි, එය ඉතා සුළු හා අතිශය වැදගත් මාතෘකාවක් බැවින් (ඔබ බහු නූල් මඟින් ප්‍රවේශ වූ හවුල් දත්ත වෙනස් කරන්නේ නම්). එය සිදු කිරීමෙන් පසු, පැහැදිලි සමමුහුර්තකරණය භාවිතා කිරීමෙන් වැළකී සිටීමට උපකාර වන java.util.concurrent පැකේජයේ පන්ති දෙස බැලීමට මම උපදෙස් දෙමි, එමඟින් වැඩසටහන් සරල හා කාර්යක්ෂමව තබා ගැනීමට උපකාරී වේ.

එවැනි එක් උදාහරණයක් වන්නේ සමගාමී ලින්ක්ඩෙක් . විධාන රටාව සමඟ සමගාමී පෝලිමේ විධාන පුරවා ඉහළ කාර්යක්ෂම සේවක නූල් නිර්මාණය කිරීමට එය ඉඩ දෙයි - පැහැදිලි සමමුහුර්ත කිරීමක් අවශ්‍ය නොවේ, අවහිරතා නොමැත, පැහැදිලි නින්දක් () අවශ්‍ය නොවේ, ටේක් () ඇමතීමෙන් පෝලිම ඡන්දය දෙන්න.

කෙටියෙන් කිවහොත්: ඔබ නූල් ආරම්භ කරන විට, නූල් අවසන් වන විට, වාෂ්පශීලී විචල්‍යයක් කියවන විට, ඔබ මොනිටරයක් ​​අගුළු ඇරීම (සමමුහුර්ත කොටුවක් / ශ්‍රිතයක් තබන්න) යනාදිය “මතක සමමුහුර්තකරණය” ව්‍යංගයෙන් සිදු වේ. මෙම “සමමුහුර්තකරණය” බලපායි (අර්ථයෙන් ” ") සියලුම ලිවීම් එම විශේෂිත ක්‍රියාවට පෙර සිදු කරන ලද්දකි. ඉහත සඳහන් කළ සමගාමී ලින්ක්ඩෙක් සම්බන්ධයෙන් , ප්‍රලේඛනය "පවසයි":

මතක අනුකූලතා බලපෑම්: වෙනත් සමගාමී එකතු කිරීම් වලදී මෙන්, වස්තුවක් සමගාමී ලින්ක්ඩෙක් වෙත දැමීමට පෙර ත්‍රෙඩ් එකක ක්‍රියා සිදු වේ - එම මූලද්‍රව්‍යය වෙනත් නූල් එකකට සමගාමී ලින්ක්ඩෙක් වෙතින් ප්‍රවේශ වීමට හෝ ඉවත් කිරීමට පසුව සිදු වේ.

මෙම ව්‍යංග හැසිරීම තරමක් හානිකර අංගයක් වන බැවින් බොහෝ අත්දැකීම් නොමැති බොහෝ ජාවා ක්‍රමලේඛකයින් එය ලබා දී ඇති පරිදි බොහෝ දේ ගනු ඇත. වෙනස් වැඩ බරක් ඇති තැන නිෂ්පාදනයේදී කළ යුතු යැයි සිතන දේ ජාවා විසින් සිදු නොකිරීමෙන් පසු හදිසියේම මෙම නූලට පැකිළෙයි - සහ සමගාමී ගැටළු පරීක්ෂා කිරීම තරමක් අපහසුය.

සමමුහුර්තකරණය යනු හුදෙක් තනි වස්තුවක් හා සම්බන්ධ නම් බහු නූල් විශේෂිත වස්තුවක් මත සමමුහුර්ත බ්ලොක් භාවිතා කරන්නේ නම් අපිරිසිදු කියවීම සහ ලිවීම වළක්වා ගත හැකිය. ඔබට වඩාත් පැහැදිලි බවක් ලබා දීමට, උදාහරණයක් ගැනීමට ඉඩ දෙන්න:

class MyRunnable implements Runnable {
    int var = 10;
    @Override
    public void run() {
        call();
    }

    public void call() {
        synchronized (this) {
            for (int i = 0; i < 4; i++) {
                var++;
                System.out.println("Current Thread " + Thread.currentThread().getName() + " var value "+var);
            }
        }
    }
}

public class MutlipleThreadsRunnable {
    public static void main(String[] args) {
        MyRunnable runnable1 = new MyRunnable();
        MyRunnable runnable2 = new MyRunnable();
        Thread t1 = new Thread(runnable1);
        t1.setName("Thread -1");
        Thread t2 = new Thread(runnable2);
        t2.setName("Thread -2");
        Thread t3 = new Thread(runnable1);
        t3.setName("Thread -3");
        t1.start();
        t2.start();
        t3.start();
    }
}

අපි MyRunnable පන්ති වස්තු දෙකක් නිර්මාණය කර ඇත්තෙමු, runnable1 නූල් 1 හා නූල් 3 හා ධාවනය කළ හැකි 2 නූල් 2 සමඟ පමණක් බෙදා ගැනේ. දැන් සමමුහුර්තකරණයකින් තොරව t1 සහ t3 ආරම්භ වන විට, PFB ප්‍රතිදානය මඟින් 1 සහ 3 නූල් දෙකම එකවරම var අගයට බලපාන බව යෝජනා කරයි.

Without Synchronized keyword

    Current Thread Thread -1 var value 11
    Current Thread Thread -2 var value 11
    Current Thread Thread -2 var value 12
    Current Thread Thread -2 var value 13
    Current Thread Thread -2 var value 14
    Current Thread Thread -1 var value 12
    Current Thread Thread -3 var value 13
    Current Thread Thread -3 var value 15
    Current Thread Thread -1 var value 14
    Current Thread Thread -1 var value 17
    Current Thread Thread -3 var value 16
    Current Thread Thread -3 var value 18

සමමුහුර්තකරණය භාවිතා කරමින්, නූල් 3 සියලු අවස්ථා වලදී නූල් 1 සම්පූර්ණ වන තෙක් බලා සිටී. අගුල් දෙකක් අත්පත් කර ගෙන ඇති අතර, එකක් ධාවනය කළ හැකි 1 මත නූල් 1 සහ නූල් 3 විසින් බෙදාගෙන ඇති අතර තවත් එකක් ධාවනය කළ හැකි 2 මත බෙදාගෙන ඇත්තේ නූල් 2 මගින් පමණි.

Current Thread Thread -1 var value 11
Current Thread Thread -2 var value 11
Current Thread Thread -1 var value 12
Current Thread Thread -2 var value 12
Current Thread Thread -1 var value 13
Current Thread Thread -2 var value 13
Current Thread Thread -1 var value 14
Current Thread Thread -2 var value 14
Current Thread Thread -3 var value 15
Current Thread Thread -3 var value 16
Current Thread Thread -3 var value 17
Current Thread Thread -3 var value 18

සමමුහුර්ත සරල යනු නූල් දෙකකට එකවර වාරණය / ක්‍රමයට ප්‍රවේශ විය නොහැක. පංතියක ඕනෑම වාරණයක් / ක්‍රමයක් සමමුහුර්ත කර ඇති බව අප පවසන විට එයින් අදහස් වන්නේ වරකට ඒවාට පිවිසිය හැක්කේ එක් නූල් එකකට පමණක් බවයි. අභ්‍යන්තරව එයට පිවිසීමට උත්සාහ කරන නූල් මුලින්ම එම වස්තුවට අගුලක් ගන්නා අතර මෙම අගුල නොමැති තාක් කල් වෙනත් කිසිදු නූලකට පන්තියේ එම අවස්ථාවෙහි සමමුහුර්ත ක්‍රම / කොටස් වලට ප්‍රවේශ විය නොහැක.

සමමුහුර්ත කිරීමට අර්ථ දක්වා නැති එකම වස්තුවක ක්‍රමයකට වෙනත් නූලකට ප්‍රවේශ විය හැකි බව සලකන්න. නූල් එකකට ඇමතුමෙන් අගුල නිදහස් කළ හැකිය

Object.wait()

synchronizedජාවා හි බ්ලොක් යනු බහු තෙරපුමේ මොනිටරයකි. synchronizedඑකම වස්තුවක් / පංතියක් සහිත වාරණය ක්‍රියාත්මක කළ හැක්කේ තනි නූල් වලින් පමණි, අනෙක් සියල්ලෝම බලා සිටිති. එය ඔබට උපකාර race conditionනූල් කිහිපයක් (පළමු පියවර භාවිතා කරන එම විචල්ය යාවත්කාලීන කිරීමට උත්සාහ කරන විට, තත්වය volatile^ගැන )

Java 5^[ගැන]synchronized සහය දක්වමින් දීර් extended කර ඇතhappens-before

මොනිටරයක අගුළු ඇරීම (සමමුහුර්ත බ්ලොක් හෝ ක්‍රමයෙන් පිටවීම) සිදු වේ - එම මොනිටරයේ සෑම පසු අගුලකටම (සමමුහුර්ත බ්ලොක් හෝ ක්‍රම ඇතුළත් කිරීම්).

ඊළඟ පියවර වන්නේ java.util.concurrent

වාෂ්පශීලී එදිරිව සමමුහුර්ත

සමමුහුර්තකරණය යනු ජාවා හි ප්‍රධාන පදයක් වන අතර එය මතක නොගැලපීම සහ නූල් ඇඟිලි ගැසීම් දෝෂ මඟහරවා ගැනීම සඳහා බහු-කියවීමේ පරිසරයේ සම්බන්ධතාවයට පෙර සිදු කිරීමට භාවිතා කරයි.