प्रदर्शन के संदर्भ में बात करना:
टी एल; डॉ
उपयोग isInstance या instanceof जो इसी तरह के प्रदर्शन की है। isAignignableFrom थोड़ा धीमा है।
प्रदर्शन द्वारा क्रमबद्ध:
- isInstance
- उदाहरण (+ 0.5%)
- isAignignableFrom (+ 2.7%)
JAVA 8 विंडोज x64 पर 2000 पुनरावृत्तियों के एक बेंचमार्क के आधार पर, 20 वार्मअप पुनरावृत्तियों के साथ।
सिद्धांत रूप में
एक नरम जैसे बायटेकोड दर्शक का उपयोग करके हम प्रत्येक ऑपरेटर को बायटेकोड में अनुवाद कर सकते हैं।
के संदर्भ में:
package foo;
public class Benchmark
{
public static final Object a = new A();
public static final Object b = new B();
...
}
जावा:
b instanceof A;
बाईटकोड:
getstatic foo/Benchmark.b:java.lang.Object
instanceof foo/A
जावा:
A.class.isInstance(b);
बाईटकोड:
ldc Lfoo/A; (org.objectweb.asm.Type)
getstatic foo/Benchmark.b:java.lang.Object
invokevirtual java/lang/Class isInstance((Ljava/lang/Object;)Z);
जावा:
A.class.isAssignableFrom(b.getClass());
बाईटकोड:
ldc Lfoo/A; (org.objectweb.asm.Type)
getstatic foo/Benchmark.b:java.lang.Object
invokevirtual java/lang/Object getClass(()Ljava/lang/Class;);
invokevirtual java/lang/Class isAssignableFrom((Ljava/lang/Class;)Z);
मापने कितने बाईटकोड निर्देश प्रत्येक ऑपरेटर द्वारा उपयोग किया जाता है, हम उम्मीद कर सकता है instanceof और isInstance तुलना में तेजी से होने की isAssignableFrom । हालाँकि, वास्तविक प्रदर्शन बाईटेकोड द्वारा नहीं बल्कि मशीन कोड (जो कि प्लेटफॉर्म पर निर्भर है) द्वारा निर्धारित किया जाता है। प्रत्येक ऑपरेटर के लिए एक माइक्रो बेंचमार्क करते हैं।
बेंचमार्क
क्रेडिट: जैसा कि @ aleksandr-dubinsky द्वारा सलाह दी गई है, और आधार कोड प्रदान करने के लिए @yura को धन्यवाद, यहाँ एक है JMH बेंचमार्क है (यह ट्यूनिंग गाइड देखें ):
class A {}
class B extends A {}
public class Benchmark {
public static final Object a = new A();
public static final Object b = new B();
@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean testInstanceOf()
{
return b instanceof A;
}
@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean testIsInstance()
{
return A.class.isInstance(b);
}
@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean testIsAssignableFrom()
{
return A.class.isAssignableFrom(b.getClass());
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(TestPerf2.class.getSimpleName())
.warmupIterations(20)
.measurementIterations(2000)
.forks(1)
.build();
new Runner(opt).run();
}
}
निम्नलिखित परिणाम दिए (स्कोर है एक समय इकाई में कई ऑपरेशन हैं , इसलिए स्कोर जितना अधिक होगा):
Benchmark Mode Cnt Score Error Units
Benchmark.testIsInstance thrpt 2000 373,061 ± 0,115 ops/us
Benchmark.testInstanceOf thrpt 2000 371,047 ± 0,131 ops/us
Benchmark.testIsAssignableFrom thrpt 2000 363,648 ± 0,289 ops/us
चेतावनी
- बेंचमार्क जेवीएम और प्लेटफॉर्म पर निर्भर है। चूंकि प्रत्येक ऑपरेशन के बीच कोई महत्वपूर्ण अंतर नहीं हैं, इसलिए एक अलग जावा संस्करण और / या सोलारिस, मैक या लिनक्स जैसे प्लेटफार्मों पर एक अलग परिणाम (और शायद अलग-अलग आदेश) प्राप्त करना संभव हो सकता है।
- बेंचमार्क "बी के ए उदाहरण है" की तुलना करता है जब "बी सीधे ए" फैलता है। यदि वर्ग पदानुक्रम अधिक गहरा और अधिक जटिल है (जैसे बी एक्स का विस्तार करता है जो वाई का विस्तार करता है जो जेड का विस्तार करता है जो ए का विस्तार करता है), तो परिणाम भिन्न हो सकते हैं।
- आमतौर पर यह सलाह दी जाती है कि पहले एक ऑपरेटर (सबसे सुविधाजनक) लेने वाले कोड को लिखने के लिए और फिर एक प्रदर्शन अड़चन होने की जाँच करने के लिए अपने कोड को प्रोफाइल करें। शायद यह ऑपरेटर आपके कोड के संदर्भ में नगण्य है, या हो सकता है ...
- पिछले बिंदु
instanceofके संबंध में, आपके कोड के संदर्भ में isInstanceउदाहरण के लिए अधिक आसानी से अनुकूलित किया जा सकता है ...
आपको एक उदाहरण देने के लिए, निम्नलिखित लूप लें:
class A{}
class B extends A{}
A b = new B();
boolean execute(){
return A.class.isAssignableFrom(b.getClass());
// return A.class.isInstance(b);
// return b instanceof A;
}
// Warmup the code
for (int i = 0; i < 100; ++i)
execute();
// Time it
int count = 100000;
final long start = System.nanoTime();
for(int i=0; i<count; i++){
execute();
}
final long elapsed = System.nanoTime() - start;
JIT के लिए धन्यवाद, कुछ बिंदु पर कोड को अनुकूलित किया गया है और हम प्राप्त करते हैं:
- Instof: 6ms
- isstance: 12ms
- isAignignableFrom: 15ms
ध्यान दें
मूल रूप से यह पोस्ट कच्चे JAVA में लूप के लिए अपने स्वयं के बेंचमार्क का उपयोग कर रही थी , जिसने अविश्वसनीय परिणाम दिए जैसे कि जस्ट इन टाइम जैसे लूप को खत्म कर सकता है। इसलिए यह ज्यादातर माप रहा था कि लूप का अनुकूलन करने के लिए जेआईटी कंपाइलर को कितनी देर लगी: प्रदर्शन परीक्षण को पुनरावृत्तियों की संख्या से स्वतंत्र देखें अधिक विवरण के लिए देखें
संबंधित सवाल