এখানে ব্যতিক্রম একটি ভাল লেখার আছে।
http://shipilev.net/blog/2014/exceptional-performance/
উপসংহার যে স্ট্যাক ট্রেস নির্মাণ এবং স্ট্যাক আনইন্ডিং ব্যয়বহুল অংশ। নীচের কোডটি এমন একটি বৈশিষ্ট্যের সুযোগ নিয়েছে 1.7যেখানে আমরা স্ট্যাকের চিহ্নগুলি চালু এবং বন্ধ করতে পারি। এরপরে আমরা বিভিন্ন পরিস্থিতিতে বিভিন্ন ধরণের কী কী খরচ হয় তা দেখতে এটি ব্যবহার করতে পারি
নিচে একা অবজেক্ট তৈরির সময় রয়েছে tim আমি Stringএখানে যুক্ত করেছি যাতে আপনি দেখতে পারেন যে স্ট্যাকটি লিখিত না থাকলে কোনও JavaExceptionঅবজেক্ট এবং ক তৈরির ক্ষেত্রে প্রায় কোনও পার্থক্য নেই String। স্ট্যাক রাইটিংটি পার্থক্যটি চালু করার সাথে নাটকীয় অর্থাৎ কমপক্ষে কমপক্ষে একটি ক্রমের মান কমিয়ে দেওয়া হয়।
Time to create million String objects: 41.41 (ms)
Time to create million JavaException objects with stack: 608.89 (ms)
Time to create million JavaException objects without stack: 43.50 (ms)
নিম্নলিখিতটি দেখায় যে একটি নির্দিষ্ট গভীরতায় এক মিলিয়ন বার কোনও নিক্ষেপ থেকে ফিরে আসতে কতক্ষণ সময় লেগেছে।
|Depth| WriteStack(ms)| !WriteStack(ms)| Diff(%)|
| 16| 1428| 243| 588 (%)|
| 15| 1763| 393| 449 (%)|
| 14| 1746| 390| 448 (%)|
| 13| 1703| 384| 443 (%)|
| 12| 1697| 391| 434 (%)|
| 11| 1707| 410| 416 (%)|
| 10| 1226| 197| 622 (%)|
| 9| 1242| 206| 603 (%)|
| 8| 1251| 207| 604 (%)|
| 7| 1213| 208| 583 (%)|
| 6| 1164| 206| 565 (%)|
| 5| 1134| 205| 553 (%)|
| 4| 1106| 203| 545 (%)|
| 3| 1043| 192| 543 (%)|
নীচেরটি প্রায় সরলীকরণের তুলনায় অবশ্যই একটি স্থূল ...
যদি আমরা স্ট্যাক রাইটিং দিয়ে 16 এর গভীরতা নিয়ে যাই তবে অবজেক্ট তৈরিতে সময় প্রায় 40% ডলার লাগবে, প্রকৃত স্ট্যাকটি এর বিশাল অংশের জন্য খাঁটি। Java 93% জাভেক্সিপশন অবজেক্টটি তাত্ক্ষণিকভাবে স্ট্যাকের সন্ধানের কারণে নেওয়া হয়েছে। এর অর্থ হল যে এই ক্ষেত্রে স্ট্যাকটি আনওয়াইন্ডিং করা হচ্ছে অন্যান্য 50% সময় নিচ্ছে is
যখন আমরা স্ট্যাক ট্রেস অবজেক্ট তৈরির অ্যাকাউন্টগুলিকে অনেক ছোট ভগ্নাংশের জন্য অর্থাৎ 20% এবং স্ট্যাক আনওয়াইন্ডিং বন্ধ করে দিই তখন সময়ের 80% হয়।
উভয় ক্ষেত্রে স্ট্যাক আনওয়াইন্ডিং সামগ্রিক সময়ের একটি বড় অংশ নেয়।
public class JavaException extends Exception {
JavaException(String reason, int mode) {
super(reason, null, false, false);
}
JavaException(String reason) {
super(reason);
}
public static void main(String[] args) {
int iterations = 1000000;
long create_time_with = 0;
long create_time_without = 0;
long create_string = 0;
for (int i = 0; i < iterations; i++) {
long start = System.nanoTime();
JavaException jex = new JavaException("testing");
long stop = System.nanoTime();
create_time_with += stop - start;
start = System.nanoTime();
JavaException jex2 = new JavaException("testing", 1);
stop = System.nanoTime();
create_time_without += stop - start;
start = System.nanoTime();
String str = new String("testing");
stop = System.nanoTime();
create_string += stop - start;
}
double interval_with = ((double)create_time_with)/1000000;
double interval_without = ((double)create_time_without)/1000000;
double interval_string = ((double)create_string)/1000000;
System.out.printf("Time to create %d String objects: %.2f (ms)\n", iterations, interval_string);
System.out.printf("Time to create %d JavaException objects with stack: %.2f (ms)\n", iterations, interval_with);
System.out.printf("Time to create %d JavaException objects without stack: %.2f (ms)\n", iterations, interval_without);
JavaException jex = new JavaException("testing");
int depth = 14;
int i = depth;
double[] with_stack = new double[20];
double[] without_stack = new double[20];
for(; i > 0 ; --i) {
without_stack[i] = jex.timerLoop(i, iterations, 0)/1000000;
with_stack[i] = jex.timerLoop(i, iterations, 1)/1000000;
}
i = depth;
System.out.printf("|Depth| WriteStack(ms)| !WriteStack(ms)| Diff(%%)|\n");
for(; i > 0 ; --i) {
double ratio = (with_stack[i] / (double) without_stack[i]) * 100;
System.out.printf("|%5d| %14.0f| %15.0f| %2.0f (%%)| \n", i + 2, with_stack[i] , without_stack[i], ratio);
//System.out.printf("%d\t%.2f (ms)\n", i, ratio);
}
}
private int thrower(int i, int mode) throws JavaException {
ExArg.time_start[i] = System.nanoTime();
if(mode == 0) { throw new JavaException("without stack", 1); }
throw new JavaException("with stack");
}
private int catcher1(int i, int mode) throws JavaException{
return this.stack_of_calls(i, mode);
}
private long timerLoop(int depth, int iterations, int mode) {
for (int i = 0; i < iterations; i++) {
try {
this.catcher1(depth, mode);
} catch (JavaException e) {
ExArg.time_accum[depth] += (System.nanoTime() - ExArg.time_start[depth]);
}
}
//long stop = System.nanoTime();
return ExArg.time_accum[depth];
}
private int bad_method14(int i, int mode) throws JavaException {
if(i > 0) { this.thrower(i, mode); }
return i;
}
private int bad_method13(int i, int mode) throws JavaException {
if(i == 13) { this.thrower(i, mode); }
return bad_method14(i,mode);
}
private int bad_method12(int i, int mode) throws JavaException{
if(i == 12) { this.thrower(i, mode); }
return bad_method13(i,mode);
}
private int bad_method11(int i, int mode) throws JavaException{
if(i == 11) { this.thrower(i, mode); }
return bad_method12(i,mode);
}
private int bad_method10(int i, int mode) throws JavaException{
if(i == 10) { this.thrower(i, mode); }
return bad_method11(i,mode);
}
private int bad_method9(int i, int mode) throws JavaException{
if(i == 9) { this.thrower(i, mode); }
return bad_method10(i,mode);
}
private int bad_method8(int i, int mode) throws JavaException{
if(i == 8) { this.thrower(i, mode); }
return bad_method9(i,mode);
}
private int bad_method7(int i, int mode) throws JavaException{
if(i == 7) { this.thrower(i, mode); }
return bad_method8(i,mode);
}
private int bad_method6(int i, int mode) throws JavaException{
if(i == 6) { this.thrower(i, mode); }
return bad_method7(i,mode);
}
private int bad_method5(int i, int mode) throws JavaException{
if(i == 5) { this.thrower(i, mode); }
return bad_method6(i,mode);
}
private int bad_method4(int i, int mode) throws JavaException{
if(i == 4) { this.thrower(i, mode); }
return bad_method5(i,mode);
}
protected int bad_method3(int i, int mode) throws JavaException{
if(i == 3) { this.thrower(i, mode); }
return bad_method4(i,mode);
}
private int bad_method2(int i, int mode) throws JavaException{
if(i == 2) { this.thrower(i, mode); }
return bad_method3(i,mode);
}
private int bad_method1(int i, int mode) throws JavaException{
if(i == 1) { this.thrower(i, mode); }
return bad_method2(i,mode);
}
private int stack_of_calls(int i, int mode) throws JavaException{
if(i == 0) { this.thrower(i, mode); }
return bad_method1(i,mode);
}
}
class ExArg {
public static long[] time_start;
public static long[] time_accum;
static {
time_start = new long[20];
time_accum = new long[20];
};
}
এই উদাহরণের স্ট্যাক ফ্রেমগুলি আপনি সাধারণত যা খুঁজে পাবেন তার তুলনায় খুব ছোট।
জাভাপ ব্যবহার করে আপনি বাইটকোডে উঁকি দিতে পারেন
javap -c -v -constants JavaException.class
অর্থাৎ এটি পদ্ধতি 4 এর জন্য ...
protected int bad_method3(int, int) throws JavaException;
flags: ACC_PROTECTED
Code:
stack=3, locals=3, args_size=3
0: iload_1
1: iconst_3
2: if_icmpne 12
5: aload_0
6: iload_1
7: iload_2
8: invokespecial #6 // Method thrower:(II)I
11: pop
12: aload_0
13: iload_1
14: iload_2
15: invokespecial #17 // Method bad_method4:(II)I
18: ireturn
LineNumberTable:
line 63: 0
line 64: 12
StackMapTable: number_of_entries = 1
frame_type = 12 /* same */
Exceptions:
throws JavaException