“Java.lang.OutOfMemoryError: PermGen space” දෝෂය සමඟ කටයුතු කිරීම

මෑතකදී මම මගේ වෙබ් යෙදුමේ මෙම දෝෂයට මුහුණ දුන්නා:

java.lang.OutOfMemoryError: PermGen අවකාශය

එය ටොම්කාට් 6 සහ ජේඩීකේ 1.6 මත ධාවනය වන සාමාන්‍ය ශිශිර / ජේපීඒ + අයිස්ෆේස් / ජේඑස්එෆ් යෙදුමකි. යෙදුමක් කිහිප වතාවක් නැවත යෙදවීමෙන් පසුව මෙය සිදුවිය හැකිය.

එයට හේතුව කුමක්ද සහ එය වළක්වා ගැනීමට කළ හැක්කේ කුමක්ද? ගැටලුව විසඳන්නේ කෙසේද?

විසඳුම වූයේ ටොම්කාට් ආරම්භ කරන විට මෙම ධජ JVM විධාන රේඛාවට එක් කිරීමයි:

-XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled

ඔබට එය කළ හැක්කේ ටොම්කාට් සේවාව වසා දැමීමෙන් පසුව ටොම්කාට් / බින් ඩිරෙක්ටරියට ගොස් tomcat6w.exe ධාවනය කිරීමෙන් ය. "ජාවා" ටැබය යටතේ, "ජාවා විකල්ප" කොටුවට තර්ක එකතු කරන්න. "හරි" ක්ලික් කර සේවාව නැවත ආරම්භ කරන්න.

ඔබට දෝෂයක් ඇති වුවහොත්, ඔබ විසින් ක්‍රියාත්මක කළ යුතු ස්ථාපිත සේවාවක් ලෙස නිශ්චිත සේවාව නොපවතී :

tomcat6w //ES//servicename

එහිදී servicename services.msc ද මේ වන විට දැකිය ලෙස සේවාදායකය නම වේ

මූලාශ්‍රය: එරික්ගේ කඩිනම් පිළිතුරු පිළිබඳ ඕක්ස්ගේ ප්‍රකාශය .

ඔබ උත්සාහ -XX:MaxPermSize=128Mකරනවාට වඩා උත්සාහ කිරීම හොඳය -XX:MaxPermGen=128M.

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

යෙදුම් සේවාදායකය PermGen දෝෂ බොහෝ විට යෙදවීමෙන් පසුව සිදුවිය හැක්කේ ඔබේ පැරණි යෙදුම්වල පන්ති භාරකරුවන් වෙත බහාලුම් විසින් යොමු කර ඇති යොමු කිරීම් නිසා ය. නිදසුනක් ලෙස, අභිරුචි ලොග් මට්ටමේ පන්තියක් භාවිතා කිරීම යෙදුම් සේවාදායකයේ පන්ති භාරකරු විසින් යොමු කිරීම් රඳවා තබා ගනී. ඔබගේ යෙදුමේ කුමන පන්ති දිගටම පවත්වන්නේ දැයි බැලීමට සහ ඒවායේ භාවිතය නැවත සැලසුම් කිරීම හෝ ඉවත් කිරීම සඳහා නවීන (JDK6 +) JVM විශ්ලේෂණ මෙවලම් වන jmap සහ jhat භාවිතා කිරීමෙන් ඔබට මෙම අන්තර් පංති කාන්දුවීම් හඳුනාගත හැකිය. සාමාන්‍ය සැකකරුවන් වන්නේ දත්ත සමුදායන්, ල gers ු-සටහන් සහ වෙනත් මූලික රාමු මට්ටමේ පුස්තකාල ය.

ශුද්ධාසනයේ Classloader කාන්දු: වැලලීමට "java.lang.OutOfMemoryError: PermGen අවකාශය" හැර , විශේෂයෙන් එහි followup පශ්චාත් .

මිනිසුන් කරන පොදු වැරදි වන්නේ ගොඩවල් අවකාශය සහ පර්මන් අවකාශය එක හා සමාන යැයි සිතීමයි. එය කිසිසේත්ම සත්‍ය නොවේ. ඔබට ගොඩවල විශාල ඉඩ ප්‍රමාණයක් ඉතිරිව තිබිය හැකි නමුත් තවමත් පර්ම්ජන් හි මතකය නැති වී යා හැකිය.

PermGen හි OutofMemory සඳහා පොදු හේතු වන්නේ ClassLoader ය. පංතියක් ජේවීඑම් වෙත පටවන සෑම අවස්ථාවකම, එහි සියලුම මෙටා දත්ත, ක්ලැස්ලෝඩර් සමඟ, පර්ම්ජෙන් ප්‍රදේශයේ තබා ඇති අතර, ඒවා පටවා ඇති පන්ති භාරකරු කසළ එකතු කිරීමට සූදානම් වන විට ඒවා එකතු කරනු ලැබේ. කේස් ක්ලැස්ලෝඩරයේ මතකය කාන්දු වී ඇති අතර එය පටවා ඇති සියලුම පංති මතකයේ රැඳෙනු ඇති අතර ඔබ එය දෙවරක් පුනරාවර්තනය කළ පසු පර්ම්ජෙන් අවුට්මොමරි ඇති කරයි. සම්භාව්‍ය උදාහරණය වන්නේ Java.lang.OutOfMemoryError: ටොම්කාට් හි PermGen Space .

දැන් මෙය විසඳීමට ක්‍රම දෙකක් තිබේ:
1. මතක කාන්දු වීමට හේතුව හෝ මතක කාන්දු වීමක් තිබේ නම්.
2. JVM param -XX:MaxPermSizeසහ -XX:PermSize. භාවිතා කරමින් PermGen අවකාශයේ ප්‍රමාණය වැඩි කරන්න .

වැඩි විස්තර සඳහා ඔබට Java.lang.OutOfMemoryError හි 2 විසඳුම පරීක්ෂා කළ හැකිය .

-XX:MaxPermSize=128mසන් ජේවීඑම් සඳහා විධාන රේඛා පරාමිතිය භාවිතා කරන්න (පැහැදිලිවම ඔබට අවශ්‍ය ඕනෑම ප්‍රමාණයකට 128 ආදේශ කිරීම).

උත්සාහ කරන්න -XX:MaxPermSize=256m, එය දිගටම පවතින්නේ නම්, උත්සාහ කරන්න-XX:MaxPermSize=512m

මම එකතු -XX: MaxPermSize = 128m කිරීමට (ඔබ හොඳින් ක්රියා කරන අත්හදා බැලීම් කළ හැකිය) VM තර්ක මම ග්රහණය ide භාවිතා කරනවා විය. බොහෝ JVM හි, පෙරනිමි PermSize 64MB පමණ වන අතර එය ව්‍යාපෘතියේ පන්ති හෝ විශාල සංඛ්‍යාවක් තිබේ නම් මතකය නැති වේ.

සූර්යග්‍රහණය සඳහා, එය පිළිතුරෙන් ද විස්තර කෙරේ .

පියවර 1 : සර්වර්ස් ටැබ් හි ටොම්කාට් සේවාදායකය මත දෙවරක් ක්ලික් කරන්න

පියවර 2 : දියත් කිරීමේ වින්‍යාසය විවෘත-XX: MaxPermSize = 128m කර පවතින VM තර්කවල අවසානයට එක් කරන්න .

සංකීර්ණ වෙබ් යෙදුමක් යෙදවීමේදී සහ යෙදවීමේදී මම මෙම ගැටළුවට එරෙහිව හිස ගසා ඇති අතර, පැහැදිලි කිරීමක් සහ මගේ විසඳුම එකතු කිරීමට සිතුවෙමි.

මම Apache Tomcat හි යෙදුමක් යෙදූ විට, එම යෙදුම සඳහා නව ClassLoader එකක් සාදනු ලැබේ. පංතියේ ලෝඩරය පසුව යෙදුමේ සියලුම පංති පැටවීමට භාවිතා කරන අතර, යෙදවීම මත සෑම දෙයක්ම මනාව ඉවතට යා යුතුය. කෙසේ වෙතත්, යථාර්ථයේ දී එය එතරම් සරල නැත.

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

නැවත සේවයේ යෙදවීමෙන් පසුව, අපට OutOfMemoryError හමුවෙයි.

දැන් මෙය තරමක් බරපතල ගැටළුවක් බවට පත්ව ඇත. එක් එක් නැවත යෙදවීමෙන් පසුව ටොම්කාට් නැවත ආරම්භ කරන බවට මට සහතික විය හැකිය, නමුත් එමඟින් යෙදුම නැවත සේවයේ යෙදවීමට වඩා සමස්ත සේවාදායකයම ඉවත් කරයි, එය බොහෝ විට කළ නොහැකි ය.

ඒ නිසා මම ඒ වෙනුවට Apache Tomcat 6.0 හි ක්‍රියාකරන කේතයක් විසඳුමක් ඉදිරිපත් කර ඇත්තෙමි. මම වෙනත් යෙදුම් සේවාදායකයන් මත පරීක්‍ෂා කර නොමැති අතර, වෙනත් යෙදුම් සේවාදායකයක වෙනස් කිරීමකින් තොරව මෙය ක්‍රියා නොකරනු ඇතැයි අවධාරණය කළ යුතුය .

පුද්ගලිකව මම මෙම කේතයට වෛර කරන බවත්, නිසි වසා දැමීම සහ පිරිසිදු කිරීමේ ක්‍රම භාවිතා කිරීම සඳහා පවතින කේතය වෙනස් කළ හැකි නම් කිසිවෙකු මෙය "ඉක්මන් විසඳුමක්" ලෙස භාවිතා නොකළ යුතු බවත් මම කියන්නට කැමැත්තෙමි. . මෙය භාවිතා කළ යුතු එකම අවස්ථාව වන්නේ ඔබේ කේතය රඳා පවතින බාහිර පුස්තකාලයක් තිබේ නම් (මගේ නඩුවේ එය රේඩියස් සේවාදායකයෙක්) එහි ස්ථිතික යොමු කිරීම් පිරිසිදු කිරීමට ක්‍රමයක් සපයන්නේ නැත.

කෙසේ වෙතත්, කේතය සමඟ ඉදිරියට යන්න. සර්වට්ලට් විනාශ කිරීමේ ක්‍රමය හෝ (වඩා හොඳ ප්‍රවේශය) සර්වට්කොන්ටෙක්ස්ට්ලිස්ටනර්ගේ සන්දර්භය ඩෙස්ට්‍රොයිඩ් ක්‍රමය වැනි යෙදුම ක්‍රියා විරහිත වන ස්ථානයට මෙය කැඳවිය යුතුය.

//Get a list of all classes loaded by the current webapp classloader
WebappClassLoader classLoader = (WebappClassLoader) getClass().getClassLoader();
Field classLoaderClassesField = null;
Class clazz = WebappClassLoader.class;
while (classLoaderClassesField == null && clazz != null) {
    try {
        classLoaderClassesField = clazz.getDeclaredField("classes");
    } catch (Exception exception) {
        //do nothing
    }
    clazz = clazz.getSuperclass();
}
classLoaderClassesField.setAccessible(true);

List classes = new ArrayList((Vector)classLoaderClassesField.get(classLoader));

for (Object o : classes) {
    Class c = (Class)o;
    //Make sure you identify only the packages that are holding references to the classloader.
    //Allowing this code to clear all static references will result in all sorts
    //of horrible things (like java segfaulting).
    if (c.getName().startsWith("com.whatever")) {
        //Kill any static references within all these classes.
        for (Field f : c.getDeclaredFields()) {
            if (Modifier.isStatic(f.getModifiers())
                    && !Modifier.isFinal(f.getModifiers())
                    && !f.getType().isPrimitive()) {
                try {
                    f.setAccessible(true);
                    f.set(null, null);
                } catch (Exception exception) {
                    //Log the exception
                }
            }
        }
    }
}

classes.clear();

මෙම java.lang.OutOfMemoryError: PermGenඅවකාශය පණිවිඩය මතකයේ නිත්ය උත්පාදනය ප්රදේශයක වියැකී බව පෙන්නුම් කරයි.

ඕනෑම ජාවා යෙදුම් සඳහා සීමිත මතක ප්‍රමාණයක් භාවිතා කිරීමට අවසර ඇත. යෙදුම් ආරම්භයේදී ඔබගේ විශේෂිත යෙදුමට භාවිතා කළ හැකි මතක ප්‍රමාණය නියම කර ඇත.

ජාවා මතකය පහත දැක්වෙන රූපයේ දැකිය හැකි විවිධ කලාපවලට වෙන් කර ඇත:

මෙටාස්පේස්: නව මතක අවකාශයක් බිහි වේ

JDK 8 HotSpot JVM දැන් පන්ති පාර-දත්ත නිරූපණය සඳහා දේශීය මතකය භාවිතා කරන අතර එය Metaspace ලෙස හැඳින්වේ; ඔරකල් ජේරොකිට් සහ අයිබීඑම් ජේවීඑම් වලට සමානය.

ශුභාරංචිය නම් එයින් අදහස් කරන්නේ වැඩි java.lang.OutOfMemoryError: PermGenඉඩ ප්‍රමාණයක් නොමැති බවත් Java_8_Download හෝ ඊට වැඩි භාවිතා කරමින් මෙම මතක අවකාශය සුසර කර අධීක්ෂණය කිරීමට ඔබට අවශ්‍ය නොවන බවත්ය .

විකල්පයක් ලෙස, ඔබට JRockit වෙත මාරු විය හැකි අතර එය පර්මන් වෙනස් ලෙස හැසිරවිය හැකි අතර පසුව හිරුගේ jvm වේ. එය සාමාන්‍යයෙන් වඩා හොඳ කාර්ය සාධනයක් ඇත.

http://www.oracle.com/technetwork/middleware/jrockit/overview/index.html

1) PermGen මතක ප්‍රමාණය වැඩි කිරීම

කෙනෙකුට කළ හැකි පළමු දෙය නම් ස්ථිර පරම්පරාවේ ගොඩවල් විශාලත්වය වැඩි කිරීමයි. සුපුරුදු -එක්ස්එම් (ආරම්භක ගොඩවල් ප්‍රමාණය සකසන්න) සහ -එක්ස්එම්එක්ස් (උපරිම ගොඩවල් ප්‍රමාණය සකසන්න) ජේවීඑම් තර්ක සමඟ මෙය කළ නොහැක. මෙම සාමාන්‍ය ජාවා ගොඩවල් සඳහා අවකාශය. කෙසේ වෙතත්, ස්ථිර පරම්පරාවේ විශාලත්වය විශාල කිරීම සඳහා සමාන තර්ක (අවම වශයෙන් සූර්ය / OpenJDK jvms සමඟ) භාවිතා කළ හැකිය:

 -XX:MaxPermSize=128m

පෙරනිමිය මීටර් 64 කි.

2) අතුගා දැමීම සක්‍රීය කරන්න

යහපත සඳහා එය රැකබලා ගත හැකි තවත් ක්‍රමයක් නම් පන්ති මුදා හැරීමට ඉඩ දීමයි, එවිට ඔබේ PermGen කිසි විටෙකත් ඉවර නොවේ:

-XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled

ඒ වගේ දේවල් අතීතයේ මට මැජික් වැඩ කළා. එක් දෙයක් නම්, ඒවා භාවිතා කිරීමේදී සැලකිය යුතු කාර්යසාධනයක් ඇත, මන්ද ඔබ කරන සෑම ඉල්ලීමක් සඳහාම අමතර ඉල්ලීම් 2 ක් හෝ එම රේඛා ඔස්සේ යමක් පර්මජන් අතුගා දැමීම සිදු කරයි. වෙළඳාම සමඟ ඔබේ භාවිතය සමතුලිත කිරීමට ඔබට අවශ්‍ය වනු ඇත.

මෙම දෝෂයේ විස්තර ඔබට සොයාගත හැකිය.

http://faisalbhagat.blogspot.com/2014/09/java-outofmemoryerror-permgen.html

අප මෙහි කතා කරන ගැටලුව මට තිබුණි, මගේ තත්වය සූර්යග්‍රහණය-හීලියෝස් + ටොම්කාට් + ජේඑස්එෆ් වන අතර ඔබ කරමින් සිටියේ ටොම්කාට් සඳහා සරල යෙදුමක් යෙදවීමයි. මම මෙහි එකම ගැටලුව පෙන්වමින් එය පහත පරිදි විසඳා ගතිමි.

සූර්යග්‍රහණයේදී සේවාදායක ටැබ් වෙත ගොස් මගේ නඩුවේ ටොම්කාට් 7.0 හි ලියාපදිංචි සේවාදායකය මත දෙවරක් ක්ලික් කරන්න, එය මගේ ගොනු සේවාදායකය විවෘත කරයි සාමාන්‍ය ලියාපදිංචි තොරතුරු. "සාමාන්‍ය තොරතුරු" යන කොටසේ " විවෘත දියත් කිරීමේ වින්‍යාසය" යන සබැඳිය ක්ලික් කරන්න , මෙය මෙම ඇතුළත් කිරීම් දෙක අවසානයේ එකතු කරන ලද වීඑම් තර්කවල තර්ක පටිත්තෙහි සේවාදායක විකල්ප ක්‍රියාත්මක කිරීම විවෘත කරයි.

-XX: MaxPermSize = 512m
-XX: PermSize = 512m

සහ සූදානම්.

මේ දිනවල ඇති සරලම පිළිතුර නම් ජාවා 8 භාවිතා කිරීමයි.

එය තවදුරටත් මතකය පර්ම්ජෙන් අවකාශය සඳහා පමණක් වෙන් නොකරන අතර, පර්ම්ජෙන් මතකය සාමාන්‍ය මතක සංචිතය සමඟ සම්බන්ධ වීමට ඉඩ සලසයි.

-XXPermGen...=...ජාවා 8 කිසිවක් නොකරන බවට පැමිණිලි කිරීමට ඔබට අවශ්‍ය නැතිනම් ඔබට සම්මත නොවන JVM ආරම්භක පරාමිතීන් ඉවත් කිරීමට සිදුවන බව මතක තබා ගන්න .

1. ටොම්කාට්ගේ බින් ඩිරෙක්ටරියෙන් ටොම්කාට් 7 විවෘත කරන්න හෝ ආරම්භක මෙනුවේ මොනිටර් ටොම්කාට් ටයිප් කරන්න (විවිධ සේවා තොරතුරු සහිත ටැබ් කවුළුවක් විවෘත වේ).

2. ජාවා විකල්ප පෙළ ප්‍රදේශය තුළ මෙම පේළිය එකතු කරන්න:

   -XX:MaxPermSize=128m

3. ආරම්භක මතක සංචිතය 1024 ලෙස සකසන්න (අත්‍යවශ්‍ය නොවේ).
4. උපරිම මතක සංචිතය 1024 ලෙස සකසන්න (අත්‍යවශ්‍ය නොවේ).
5. හරි ක්ලික් කරන්න.
6. ටොම්කාට් සේවාව නැවත ආරම්භ කරන්න.

Perm gen space error සිදුවන්නේ විශාල ඉඩක් භාවිතා කිරීම නිසා jvm කේතය ක්‍රියාත්මක කිරීමට ඉඩ ලබා දීමෙනි.

යුනික්ස් මෙහෙයුම් පද්ධතිවල මෙම ගැටලුවට හොඳම විසඳුම වන්නේ බාෂ් ගොනුවේ යම් වින්‍යාසයක් වෙනස් කිරීමයි. පහත පියවරයන් ගැටළුව විසඳයි.

gedit .bashrcටර්මිනලය මත විධානය ක්‍රියාත්මක කරන්න .

JAVA_OTPSපහත අගය සමඟ විචල්‍යය සාදන්න :

export JAVA_OPTS="-XX:PermSize=256m -XX:MaxPermSize=512m"

Bash ගොනුව සුරකින්න. ටර්මිනලය මත විධානය exec bash ධාවනය කරන්න. සේවාදායකය නැවත ආරම්භ කරන්න.

මෙම ප්රවේශය ඔබේ ගැටළුව විසඳනු ඇතැයි මම බලාපොරොත්තු වෙමි. ඔබ 8 ට වඩා අඩු ජාවා අනුවාදයක් භාවිතා කරන්නේ නම් මෙම ගැටළුව සමහර විට සිදු වේ. නමුත් ඔබ ජාවා 8 භාවිතා කරන්නේ නම් ගැටළුව කිසි විටෙකත් සිදු නොවේ.

ස්ථිර පරම්පරාවේ ප්‍රමාණය වැඩි කිරීම හෝ GC පරාමිතීන් වෙනස් කිරීම ඔබට සැබෑ මතක කාන්දුවක් ඇත්නම් උදව් නොකරනු ඇත. ඔබගේ යෙදුම හෝ එය භාවිතා කරන තෙවන පාර්ශවීය පුස්තකාලයක් නම්, පංති පැටවුම් කාන්දු වීම එකම සැබෑ හා ස්ථිර විසඳුම වන්නේ මෙම කාන්දුව සොයාගෙන එය නිවැරදි කිරීමයි. ඔබට උදව් කළ හැකි මෙවලම් ගණනාවක් තිබේ, මෑත කාලීන එකක් වන්නේ ප්ලම්බර් ය , එය අවශ්‍ය හැකියාවන් සහිත නව අනුවාදයක් නිකුත් කර ඇත.

එසේම ඔබ ඔබේ webapp දී log4j භාවිතා කරන්නේ නම්, log4j මෙම ඡේදය බලන්න ප්රලේඛනය .

ඔබ භාවිතා කරන්නේ නම් PropertyConfigurator.configureAndWatch("log4j.properties"), ඔබ ඔබේ වෙබ් යෙදුම අවලංගු කරන විට මතක කාන්දු වන බව පෙනේ.

මම හයිබනේට් + එක්ලිප්ස් රොබෝටික් භාණ්ඩ ප්රවාහන සංකලනයක් ඇති, භාවිතා උත්සාහ -XX:MaxPermSize=512mහා -XX:PermSize=512mඑය මට වැඩ කර ඇති බව පෙනේ.

සකසන්න -XX:PermSize=64m -XX:MaxPermSize=128m. පසුව ඔබට වැඩි කිරීමට උත්සාහ කළ හැකිය MaxPermSize. එය සාර්ථක වේ යැයි සිතමි. මටත් එසේමයි. සැකසීම පමණක් MaxPermSizeමට වැඩ කළේ නැත.

මම පිළිතුරු කිහිපයක් උත්සාහ කළ අතර අවසාන වශයෙන් කාර්යය කළේ පොම් හි ඇති සම්පාදක ප්ලගිනය සඳහා වූ මෙම වින්‍යාසයයි:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
        <fork>true</fork>
        <meminitial>128m</meminitial>
        <maxmem>512m</maxmem>
        <source>1.6</source>
        <target>1.6</target>
        <!-- prevent PermGen space out of memory exception -->
        <!-- <argLine>-Xmx512m -XX:MaxPermSize=512m</argLine> -->
    </configuration>
</plugin>

මේ කෙනා උදව් කරයි කියලා බලාපොරොත්තු වෙනවා.

jrockitමෙය මා වෙනුවෙන් ද විසඳා ඇත; කෙසේ වෙතත්, සර්වට් නැවත ආරම්භ කිරීමේ වේලාවන් වඩාත් නරක බව මම දුටුවෙමි, එබැවින් එය නිෂ්පාදනයේ වඩා හොඳ වුවත්, එය සංවර්ධනයේ ඇදගෙන යාමක් විය.

මතකයේ වින්‍යාසය ඔබගේ යෙදුමේ ස්වභාවය මත රඳා පවතී.

ඔයා කරන්නේ කුමක් ද?

පෙර සැකසූ ගනුදෙනු ප්‍රමාණය කොපමණද?

ඔබ කොපමණ දත්ත පටවනවාද?

ආදිය.

ආදිය.

යනාදිය

බොහෝ විට ඔබට ඔබගේ යෙදුම පැතිකඩ කර ඔබගේ යෙදුමෙන් මොඩියුල කිහිපයක් පිරිසිදු කිරීම ආරම්භ කළ හැකිය.

යෙදුමක් කිහිප වතාවක් නැවත යෙදවීමෙන් පසුව මෙය සිදුවිය හැකිය

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

ටොම්කාට් හි නවතම සංශෝධනය (6.0.28 හෝ 6.0.29) විසින් සේවාදායකයින් නැවත සේවයේ යෙදවීමේ කාර්යය වඩා හොඳින් හසුරුවන බව ඔවුහු කියති .

මම හරියටම එකම ගැටලුවකට මුහුණ දුන්නෙමි, නමුත් අවාසනාවකට යෝජිත විසඳුම් කිසිවක් මට සාර්ථක වූයේ නැත. යෙදවීමේදී ගැටළුව සිදු නොවූ අතර මම කිසිදු උණුසුම් යෙදවීමක් කළේ නැත.

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

මෙම සබැඳිය (කලින් සඳහන් කළ) ගැටළුව විසඳීමට ප්‍රමාණවත් තරම් තොරතුරු සපයයි. Jdbc- (mysql) ඩ්‍රයිවර් WEB-INF වෙතින් ඉවත් කර jre / lib / ext / ෆෝල්ඩරයට ගෙන යාම ගැටළුව විසඳා ඇති බව පෙනේ. මෙය කදිම විසඳුමක් නොවේ, මන්ද නව JRE වෙත යාවත්කාලීන කිරීම මඟින් ඔබට ධාවක නැවත ස්ථාපනය කිරීමට අවශ්‍ය වනු ඇත. සමාන ගැටළු ඇති කළ හැකි තවත් අපේක්ෂකයෙකු වන්නේ log4j, එබැවින් ඔබට එය ද ගෙනයාමට අවශ්‍ය විය හැකිය

එවැනි අවස්ථාවක පළමු පියවර වන්නේ පර්ම්ජෙන් වෙතින් පන්ති බෑමට GC ට අවසර තිබේද යන්න පරීක්ෂා කිරීමයි. සම්මත ජේවීඑම් මේ සම්බන්ධයෙන් තරමක් ගතානුගතිකයි - පංති උපත ලබන්නේ සදාකල් ජීවත් වීමටයි. එබැවින් පැටවූ පසු, කිසිදු කේතයක් තවදුරටත් භාවිතා නොකලත් පන්ති මතකයේ රැඳේ. යෙදුම ගතිකව පන්ති රාශියක් නිර්මාණය කරන විට සහ ජනනය කරන ලද පන්ති දිගු කාලයක් සඳහා අවශ්‍ය නොවන විට මෙය ගැටළුවක් විය හැකිය. එවැනි අවස්ථාවක, JVM හට පන්ති අර්ථ දැක්වීම් ඉවත් කිරීමට ඉඩ දීම ප්‍රයෝජනවත් වේ. ඔබගේ ආරම්භක ස්ක්‍රිප්ට් වලට එක් වින්‍යාස පරාමිතියක් එක් කිරීමෙන් මෙය සාක්ෂාත් කරගත හැකිය:

-XX:+CMSClassUnloadingEnabled

පෙරනිමියෙන් මෙය අසත්‍ය ලෙස සකසා ඇති අතර මෙය සක්‍රීය කිරීම සඳහා ඔබට පහත විකල්පය ජාවා විකල්පයන්හි පැහැදිලිව සැකසිය යුතුය. ඔබ CMSClassUnloadingEnabled සක්‍රීය කළහොත්, GC විසින් PermGen ද අතුගා දමා තවදුරටත් භාවිතා නොකරන පන්ති ඉවත් කරනු ඇත. මෙම විකල්පය ක්‍රියාත්මක වන්නේ UseConcMarkSweepGC ද සක්‍රීය කර ඇති විට පමණක් බව මතක තබා ගන්න. එබැවින් සමාන්තර ජීසී ධාවනය කරන විට හෝ, දෙවියන් විසින් තහනම් කරන ලද, අනුක්‍රමික ජීසී, සඳහන් කිරීමෙන් ඔබේ ජීසී එක සීඑම්එස් වෙත සකසා ඇති බවට වග බලා ගන්න:

-XX:+UseConcMarkSweepGC

ටොම්කාට් හට වැඩි මතකයක් ලබා දීම නිසි විසඳුම නොවේ.

නිවැරදි විසඳුම වන්නේ සන්දර්භය විනාශ කර නැවත ප්‍රතිනිර්මාණය කිරීමෙන් පසු පිරිසිදු කිරීමක් කිරීමයි (උණුසුම් යෙදවීම). විසඳුම වන්නේ මතක කාන්දු වීම නතර කිරීමයි.

ඔබේ ටොම්කාට් / වෙබ්අප් සේවාදායකය මඟින් රියදුරන් (ජේඩීබීසී) ලියාපදිංචි කිරීමට අපොහොසත් වූ බව ඔබට කියන්නේ නම්, ඒවා ලියාපදිංචි නොකරන්න. මෙය මතක කාන්දු වීම නවත්වනු ඇත.

ඔබට ServletContextListener එකක් සාදා එය ඔබගේ web.xml හි වින්‍යාසගත කළ හැකිය. ServletContextListener නියැදිය මෙන්න:

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.log4j.Logger;

import com.mysql.jdbc.AbandonedConnectionCleanupThread;

/**
 * 
 * @author alejandro.tkachuk / calculistik.com
 *
 */
public class AppContextListener implements ServletContextListener {

    private static final Logger logger = Logger.getLogger(AppContextListener.class);

    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        logger.info("AppContextListener started");
    }

    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        logger.info("AppContextListener destroyed");

        // manually unregister the JDBC drivers
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            try {
                DriverManager.deregisterDriver(driver);
                logger.info(String.format("Unregistering jdbc driver: %s", driver));
            } catch (SQLException e) {
                logger.info(String.format("Error unregistering driver %s", driver), e);
            }

        }

        // manually shutdown clean up threads
        try {
            AbandonedConnectionCleanupThread.shutdown();
            logger.info("Shutting down AbandonedConnectionCleanupThread");
        } catch (InterruptedException e) {
            logger.warn("SEVERE problem shutting down AbandonedConnectionCleanupThread: ", e);
            e.printStackTrace();
        }        
    }
}

මෙන්න ඔබ එය ඔබගේ web.xml හි වින්‍යාස කරයි:

<listener>
    <listener-class>
        com.calculistik.mediweb.context.AppContextListener 
    </listener-class>
</listener>  

"ඔවුන්" වැරදියි, මන්ද මම 6.0.29 ධාවනය කර ඇති අතර සියලු විකල්පයන් සැකසීමෙන් පසුවද එකම ගැටළුවක් ඇත. ටිම් හොව්ලන්ඩ් ඉහත කී පරිදි, මෙම විකල්පයන් නොවැළැක්විය හැකිය. මා නැවත සේවයේ යොදවන සෑම අවස්ථාවකම දෝෂයට පෙර 3 වතාවක් නැවත සේවයේ යෙදවීමට ඔවුන් මට ඉඩ දෙයි.

ඔබ මෙම සූර්ය ග්රහණය IDE දී, පරාමිතීන් කිරීෙමන් පසු පවා ලබා ඇති අවස්ථාවක දී --launcher.XXMaxPermSize, -XX:MaxPermSizeආදිය, තවමත් ඔබ එම දෝෂය හැරෙනවා නම්, එය බොහෝ දුරට ග්රහණය සමහර ස්ථාපනය කර ඇත කරන, JRE ක සපිරි අනුවාදය භාවිතා කරන බවට ය තෙවන පාර්ශවීය යෙදුම් සහ පෙරනිමිය ලෙස සකසා ඇත. මෙම දෝෂ සහිත අනුවාදයන් PermSize පරාමිතීන් තෝරා නොගනී, එබැවින් ඔබ කුමක් සැකසූවත්, ඔබ තවමත් මෙම මතක දෝෂ ලබා ගනී. එබැවින්, ඔබේ eclipse.ini හි පහත සඳහන් පරාමිතීන් එක් කරන්න:

-vm <path to the right JRE directory>/<name of javaw executable>

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

මට වැඩ කළ එකම ක්‍රමය වූයේ JRockit JVM ය. මට MyEclipse 8.6 ඇත.

JVM හි ගොඩවල් ක්‍රියාත්මක වන ජාවා වැඩසටහනක් මඟින් ජනනය කරන සියලුම වස්තු ගබඩා කරයි. ජාවා newවස්තු නිර්මාණය කිරීම සඳහා ක්‍රියාකරු භාවිතා කරන අතර නව වස්තූන් සඳහා මතකය ධාවන වේලාවේදී ගොඩවල් මත වෙන් කරනු ලැබේ. කසළ එකතු කිරීම යනු වැඩසටහන මඟින් තවදුරටත් යොමු නොකරන ලද වස්තූන්හි ඇති මතකය ස්වයංක්‍රීයව නිදහස් කිරීමේ යාන්ත්‍රණයයි.

මටත් ඒ හා සමාන ප්‍රශ්නයක් තිබුණා. පතල යනු JDK 7 + Maven 3.0.2 + Struts 2.0 + Google GUICE යැපුම් එන්නත් පදනම් කරගත් ව්‍යාපෘතියකි.

මම mvn clean packageවිධානය ක්‍රියාත්මක කිරීමට උත්සාහ කළ සෑම විටම එය පහත දැක්වෙන දෝෂයක් පෙන්වන අතර "BUILD FAILURE" සිදුවිය

org.apache.maven.surefire.util.SurefireReflectionException: java.lang.reflect.InvocationTargetException; කැදැලි ව්‍යතිරේකය වන්නේ java.lang.reflect.InvocationTargetException: null java.lang.reflect.InvocationTargetException හේතුව: java.lang.OutOfMemoryError: PermGen space

ඉහත සියලු ප්‍රයෝජනවත් ඉඟි සහ උපක්‍රම මම උත්සාහ කළ නමුත් අවාසනාවකට ඒ කිසිවක් මා වෙනුවෙන් ක්‍රියාත්මක නොවීය. මා වෙනුවෙන් වැඩ කළ දේ පියවරෙන් පියවර විස්තර කෙරේ: =>

1. ඔබේ pom.xml වෙත යන්න
2. ඒ සඳහා සොයන්න <artifactId>maven-surefire-plugin</artifactId>
3. පහත දැක්වෙන පරිදි සම්මත වන නව <configuration>මූලද්‍රව්‍යයක් සහ <argLine>උප මූලද්‍රව්‍යයක් එක් කරන්න-Xmx512m -XX:MaxPermSize=256m

<configuration> <argLine>-Xmx512m -XX:MaxPermSize=256m</argLine> </configuration>

එය උපකාරී වේ යැයි සිතමි, ප්‍රීතිමත් වැඩසටහන් :)