जवाबों:
हाँ बिल्कुल। प्रतिबिंब के माध्यम से एक वर्ग को देखना , परिमाण द्वारा , अधिक महंगा है।
प्रतिबिंब पर जावा के प्रलेखन का हवाला देते हुए :
क्योंकि प्रतिबिंब में वे प्रकार शामिल हैं जो गतिशील रूप से हल किए गए हैं, कुछ जावा वर्चुअल मशीन अनुकूलन नहीं किए जा सकते हैं। नतीजतन, चिंतनशील संचालन में उनके गैर-चिंतनशील समकक्षों की तुलना में धीमी गति से प्रदर्शन होता है, और कोड के अनुभागों से बचा जाना चाहिए जिन्हें प्रदर्शन-संवेदनशील अनुप्रयोगों में अक्सर कहा जाता है।
यहाँ एक सरल परीक्षण है जिसे मैंने अपनी मशीन पर 5 मिनट में हैक कर लिया है, सन JRE 6u10 चला रहा है:
public class Main {
public static void main(String[] args) throws Exception
{
doRegular();
doReflection();
}
public static void doRegular() throws Exception
{
long start = System.currentTimeMillis();
for (int i=0; i<1000000; i++)
{
A a = new A();
a.doSomeThing();
}
System.out.println(System.currentTimeMillis() - start);
}
public static void doReflection() throws Exception
{
long start = System.currentTimeMillis();
for (int i=0; i<1000000; i++)
{
A a = (A) Class.forName("misc.A").newInstance();
a.doSomeThing();
}
System.out.println(System.currentTimeMillis() - start);
}
}
इन परिणामों के साथ:
35 // no reflection
465 // using reflection
देखने और तात्कालिकता को एक साथ रखकर किया जाता है, और कुछ मामलों में लुकअप को दूर किया जा सकता है, लेकिन यह सिर्फ एक मूल उदाहरण है।
यहां तक कि अगर आप सिर्फ तुरंत, आप अभी भी एक प्रदर्शन हिट हो:
30 // no reflection
47 // reflection using one lookup, only instantiating
फिर, वाईएमएमवी।
हां, यह धीमा है।
लेकिन लानत # 1 नियम को याद रखें - प्रीमेच्योर ऑप्टिमाइज़ेशन सभी EVIL की जड़ है
(खैर, DRY के लिए # 1 के साथ जोड़ा जा सकता है)
मैं कसम खाता हूं, अगर कोई मेरे पास काम पर आया और मुझसे पूछा कि मैं अगले कुछ महीनों के लिए उनके कोड पर बहुत सतर्क रहूंगा।
आपको तब तक कभी भी अनुकूलन नहीं करना चाहिए जब तक आप सुनिश्चित न हों कि आपको इसकी आवश्यकता है, तब तक, बस अच्छा, पठनीय कोड लिखें।
ओह, और मेरा मतलब बेवकूफ कोड लिखना नहीं है। बस सबसे साफ तरीके के बारे में सोचें जो आप संभवतः कर सकते हैं - कोई कॉपी और पेस्ट नहीं, आदि (फिर भी आंतरिक छोरों की तरह सामान से सावधान रहें और संग्रह का उपयोग करना जो आपकी ज़रूरत को सबसे अच्छी तरह से फिट करता है - इनको अनदेखा करना "अस्वाभाविक" प्रोग्रामिंग नहीं है , यह "खराब" प्रोग्रामिंग है)
जब मैं इस तरह के सवाल सुनता हूं, तो यह मुझे छोड़ देता है, लेकिन फिर मैं यह भूल जाता हूं कि हर किसी को सभी नियम सीखने से पहले ही गुजरना पड़ता है क्योंकि वे वास्तव में ऐसा करते हैं। किसी व्यक्ति द्वारा "ऑप्टिमाइज़्ड" किसी चीज़ पर डिबगिंग करने के बाद आपको यह मिलेगा।
संपादित करें:
इस धागे में एक दिलचस्प बात हुई। # 1 उत्तर की जाँच करें, यह उदाहरण है कि संकलक चीजों को अनुकूलित करने में कितना शक्तिशाली है। परीक्षण पूरी तरह से अमान्य है क्योंकि गैर-चिंतनशील तात्कालिकता को पूरी तरह से सचित्र किया जा सकता है।
सबक? जब तक आप एक साफ, बड़े करीने से लिखे गए समाधान को नहीं लिखते हैं, तब तक इसे अनुकूलित न करें और इसे बहुत धीमा साबित करें।
आपको लग सकता है कि A = new A () को JVM द्वारा अनुकूलित किया जा रहा है। यदि आप वस्तुओं को एक सरणी में रखते हैं, तो वे इतना अच्छा प्रदर्शन नहीं करते हैं। ;) निम्नलिखित प्रिंट ...
new A(), 141 ns
A.class.newInstance(), 266 ns
new A(), 103 ns
A.class.newInstance(), 261 ns
public class Run {
private static final int RUNS = 3000000;
public static class A {
}
public static void main(String[] args) throws Exception {
doRegular();
doReflection();
doRegular();
doReflection();
}
public static void doRegular() throws Exception {
A[] as = new A[RUNS];
long start = System.nanoTime();
for (int i = 0; i < RUNS; i++) {
as[i] = new A();
}
System.out.printf("new A(), %,d ns%n", (System.nanoTime() - start)/RUNS);
}
public static void doReflection() throws Exception {
A[] as = new A[RUNS];
long start = System.nanoTime();
for (int i = 0; i < RUNS; i++) {
as[i] = A.class.newInstance();
}
System.out.printf("A.class.newInstance(), %,d ns%n", (System.nanoTime() - start)/RUNS);
}
}
यह सुझाव देता है कि मेरी मशीन पर लगभग 150 एनएस का अंतर है।
Class.getDeclaredMethod) को ढूंढता हूं और फिर Method.invokeकई बार कॉल करता हूं ? क्या मैं एक बार प्रतिबिंब का उपयोग कर रहा हूं या जितनी बार मैं इसे आह्वान करता हूं? सवाल का पालन करें, क्या होगा अगर इसके बजाय Methodयह एक है Constructorऔर मैं Constructor.newInstanceकई बार करता हूं ?
यदि वास्तव में प्रतिबिंब की तुलना में तेजी से किसी चीज की आवश्यकता होती है, और यह सिर्फ एक समय से पहले का अनुकूलन नहीं है, तो ASM या उच्च स्तर के पुस्तकालय के साथ बाईटकोड जेनरेशन एक विकल्प है। पहली बार बाईटेकोड उत्पन्न करना केवल परावर्तन का उपयोग करने की तुलना में धीमा है, लेकिन एक बार बायटेकोड उत्पन्न हो जाने के बाद, यह सामान्य जावा कोड की तरह तेज है और इसे जेआईटी कंपाइलर द्वारा अनुकूलित किया जाएगा।
अनुप्रयोगों के कुछ उदाहरण जो कोड पीढ़ी का उपयोग करते हैं:
CGLIB द्वारा उत्पन्न परदे के पीछे की विधियों को जावा के गतिशील परदे के पीछे की तुलना में थोड़ा तेज है , क्योंकि CGLIB अपने प्रॉक्सी के लिए बायटेकोड उत्पन्न करता है, लेकिन गतिशील परदे के पीछे केवल प्रतिबिंब का उपयोग करता है ( मैंने विधि कॉलों में CGLIB को लगभग 10 गुना तेज किया, लेकिन परदे के पीछे का निर्माण धीमा था)।
जेसेरियल प्रतिबिंब का उपयोग करने के बजाय क्रमबद्ध वस्तुओं के क्षेत्रों को पढ़ने / लिखने के लिए बायटेकोड उत्पन्न करता है। JSerial की साइट पर कुछ बेंचमार्क हैं ।
मुझे 100% यकीन नहीं है (और मुझे अब स्रोत पढ़ने का मन नहीं है), लेकिन मुझे लगता है कि गुइसे निर्भरता इंजेक्शन करने के लिए बायटेकोड उत्पन्न करता है। यदि मैं गलत हूं तो मुझे सही करों।
"महत्वपूर्ण" पूरी तरह से संदर्भ पर निर्भर है।
यदि आप किसी कॉन्फ़िगरेशन फ़ाइल के आधार पर किसी एकल हैंडलर ऑब्जेक्ट को बनाने के लिए प्रतिबिंब का उपयोग कर रहे हैं, और फिर अपना शेष समय डेटाबेस क्वेरीज़ को चलाने में बिता रहे हैं, तो यह महत्वहीन है। यदि आप तंग पाश में प्रतिबिंब के माध्यम से बड़ी संख्या में ऑब्जेक्ट बना रहे हैं, तो हाँ, यह महत्वपूर्ण है।
सामान्य तौर पर, डिजाइन लचीलेपन (जहां जरूरत हो!) को प्रतिबिंब के अपने उपयोग को चलाना चाहिए, न कि प्रदर्शन को। हालांकि, यह निर्धारित करने के लिए कि प्रदर्शन एक मुद्दा है, आपको चर्चा मंच से मनमानी प्रतिक्रियाएं प्राप्त करने के बजाय प्रोफ़ाइल करने की आवश्यकता है।
परावर्तन के साथ कुछ ओवरहेड है, लेकिन यह आधुनिक वीएम पर बहुत छोटा है जितना कि यह हुआ करता था।
यदि आप अपने कार्यक्रम में प्रत्येक सरल वस्तु बनाने के लिए प्रतिबिंब का उपयोग कर रहे हैं तो कुछ गलत है। इसका उपयोग कभी-कभार, जब आपके पास अच्छा कारण होता है, तो बिल्कुल भी समस्या नहीं होनी चाहिए।
हां, प्रतिबिंब का उपयोग करते समय एक प्रदर्शन हिट होता है लेकिन अनुकूलन के लिए एक संभावित समाधान विधि को कैशिंग कर रहा है:
Method md = null; // Call while looking up the method at each iteration.
millis = System.currentTimeMillis( );
for (idx = 0; idx < CALL_AMOUNT; idx++) {
md = ri.getClass( ).getMethod("getValue", null);
md.invoke(ri, null);
}
System.out.println("Calling method " + CALL_AMOUNT+ " times reflexively with lookup took " + (System.currentTimeMillis( ) - millis) + " millis");
// Call using a cache of the method.
md = ri.getClass( ).getMethod("getValue", null);
millis = System.currentTimeMillis( );
for (idx = 0; idx < CALL_AMOUNT; idx++) {
md.invoke(ri, null);
}
System.out.println("Calling method " + CALL_AMOUNT + " times reflexively with cache took " + (System.currentTimeMillis( ) - millis) + " millis");में परिणाम होगा:
[जावा] लुकिंग विधि से १०००००० बार कॉलिंग लुकअप के साथ ५६१। मिली
[जावा] कॉलिंग विधि १०००००० बार कैश के साथ प्रतिपल २ing० मिली
प्रतिबिंब धीमा है, हालांकि ऑब्जेक्ट आवंटन प्रतिबिंब के अन्य पहलुओं की तरह निराशाजनक नहीं है। प्रतिबिंब-आधारित तात्कालिकता के साथ समान प्रदर्शन प्राप्त करने के लिए आपको अपना कोड लिखने की आवश्यकता होती है, ताकि जीट यह बता सके कि किस वर्ग को त्वरित किया जा रहा है। यदि वर्ग की पहचान निर्धारित नहीं की जा सकती है, तो आवंटन कोड को इनलाइन नहीं किया जा सकता है। इससे भी बदतर, विश्लेषण से बचना विफल हो जाता है, और ऑब्जेक्ट को स्टैक-आवंटित नहीं किया जा सकता है। यदि आप भाग्यशाली हैं, तो JVM का रन-टाइम प्रोफाइलिंग बचाव में आ सकता है यदि यह कोड गर्म हो जाता है, और गतिशील रूप से यह निर्धारित कर सकता है कि कौन सा वर्ग प्रबल होता है और उस एक के लिए अनुकूलन कर सकता है।
ध्यान रखें कि इस धागे में माइक्रोबेंचमार्क गहरी खामियां हैं, इसलिए उन्हें नमक के दाने के साथ लें। अब तक कम से कम त्रुटिपूर्ण पीटर लॉरी का है: यह विधियों को ठीक करने के लिए वार्मअप चलाता है, और यह (सचेत रूप से) यह सुनिश्चित करने के लिए विश्लेषण से पराजित होता है कि आवंटन वास्तव में हो रहे हैं। यहां तक कि एक की अपनी समस्याएं हैं, हालांकि: उदाहरण के लिए, सरणी स्टोर की जबरदस्त संख्या से कैश को हराने और बफ़र्स को स्टोर करने की उम्मीद की जा सकती है, इसलिए यदि आपके आवंटन बहुत तेज हैं, तो यह ज्यादातर मेमोरी बेंचमार्क होगा। (हालांकि पीटर को निष्कर्ष प्राप्त करने के लिए कुडोस: हालांकि यह अंतर "2.5x" के बजाय "150ns" है। मुझे संदेह है कि वह एक जीवित व्यक्ति के लिए इस तरह का काम करता है।)
दिलचस्प रूप से पर्याप्त है, सेटल करने योग्य (सच्चा), जो सुरक्षा जांच को समाप्त करता है, लागत में 20% की कमी है।
बिना असफल (सत्य)
new A(), 70 ns
A.class.newInstance(), 214 ns
new A(), 84 ns
A.class.newInstance(), 229 nsअसफल (सत्य) के साथ
new A(), 69 ns
A.class.newInstance(), 159 ns
new A(), 85 ns
A.class.newInstance(), 171 ns1000000इनवॉइस चल रहा हो ?
setAccessible()में सामान्य रूप से बहुत अधिक अंतर हो सकता है, खासकर कई तर्कों वाले तरीकों के लिए, इसलिए इसे हमेशा कहा जाना चाहिए।
हां, यह काफी धीमा है। हम कुछ कोड चला रहे थे, जो कि मेरे पास थे और इस समय मेरे पास उपलब्ध मेट्रिक्स उपलब्ध नहीं थे, अंतिम परिणाम यह था कि हमें उस कोड को रिफ्लेक्टर करना था ताकि रिफ्लेक्शन का उपयोग न किया जा सके। यदि आपको पता है कि कक्षा क्या है, तो सीधे कंस्ट्रक्टर को कॉल करें।
DoReflection () में Class.forName ("misc.A") की वजह से ओवरहेड होता है (जिसमें क्लास लुकिंग की आवश्यकता होती है, संभवतः नएइनस्टांस () के बजाय क्लास में बुलाया गया था)। मैं सोच रहा हूं कि क्या लग रहा होगा यदि Class.forName ("misc.A") फॉर-लूप के बाहर केवल एक बार किया जाता है, यह वास्तव में लूप के हर आह्वान के लिए नहीं किया जाता है।
हां, हमेशा धीमा होगा जो प्रतिबिंब द्वारा एक वस्तु का निर्माण करेगा क्योंकि JVM संकलन समय पर कोड का अनुकूलन नहीं कर सकता है। अधिक जानकारी के लिए सूर्य / जावा परावर्तन ट्यूटोरियल देखें।
देखिये यह सरल परीक्षण:
public class TestSpeed {
public static void main(String[] args) {
long startTime = System.nanoTime();
Object instance = new TestSpeed();
long endTime = System.nanoTime();
System.out.println(endTime - startTime + "ns");
startTime = System.nanoTime();
try {
Object reflectionInstance = Class.forName("TestSpeed").newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
endTime = System.nanoTime();
System.out.println(endTime - startTime + "ns");
}
}Class.forName()) को इंस्टालेशन (newInstance ()) से अलग करना चाहिए , क्योंकि वे अपने प्रदर्शन विशेषताओं में काफी भिन्न होते हैं और आप कभी-कभी एक अच्छी तरह से डिज़ाइन किए गए सिस्टम में दोहराए गए लुकअप से बच सकते हैं।
अक्सर आप Apache commons BeanUtils या PropertyUtils का उपयोग कर सकते हैं जो आत्मनिरीक्षण करते हैं (मूल रूप से वे कक्षाओं के बारे में मेटा डेटा को कैश करते हैं ताकि उन्हें हमेशा प्रतिबिंब का उपयोग करने की आवश्यकता न हो)।
मुझे लगता है कि यह इस बात पर निर्भर करता है कि लक्ष्य विधि कितनी हल्की / भारी है। यदि लक्ष्य विधि बहुत हल्की है (जैसे गेट्टर / सेटर), तो यह 1 ~ 3 गुना धीमी हो सकती है। यदि लक्ष्य विधि में लगभग 1 मिलीसेकंड या उससे अधिक का समय लगता है, तो प्रदर्शन बहुत करीब होगा। यहाँ परीक्षण मैंने जावा 8 और परावर्तन के साथ किया है :
public class ReflectionTest extends TestCase {
@Test
public void test_perf() {
Profiler.run(3, 100000, 3, "m_01 by refelct", () -> Reflection.on(X.class)._new().invoke("m_01")).printResult();
Profiler.run(3, 100000, 3, "m_01 direct call", () -> new X().m_01()).printResult();
Profiler.run(3, 100000, 3, "m_02 by refelct", () -> Reflection.on(X.class)._new().invoke("m_02")).printResult();
Profiler.run(3, 100000, 3, "m_02 direct call", () -> new X().m_02()).printResult();
Profiler.run(3, 100000, 3, "m_11 by refelct", () -> Reflection.on(X.class)._new().invoke("m_11")).printResult();
Profiler.run(3, 100000, 3, "m_11 direct call", () -> X.m_11()).printResult();
Profiler.run(3, 100000, 3, "m_12 by refelct", () -> Reflection.on(X.class)._new().invoke("m_12")).printResult();
Profiler.run(3, 100000, 3, "m_12 direct call", () -> X.m_12()).printResult();
}
public static class X {
public long m_01() {
return m_11();
}
public long m_02() {
return m_12();
}
public static long m_11() {
long sum = IntStream.range(0, 10).sum();
assertEquals(45, sum);
return sum;
}
public static long m_12() {
long sum = IntStream.range(0, 10000).sum();
assertEquals(49995000, sum);
return sum;
}
}
}पूरा परीक्षण कोड GitHub: ReflectionTest.java पर उपलब्ध है