编程知识 cdmana.com

Performance of java development specification

JAVA In development , Most of the performance problems are not due to JAVA The language itself , It's a program that we write in these languages , So it's very important to develop good coding habits .

Let's share some typical cases in daily development :

One . Internal methods in a class are declared as private

Many students think it doesn't matter , When writing code, I like that all methods in a class are public Of ( Everyone knows why ), Famous for its name : Easy to expand later ..

For methods that do not require external access, change to private , It's not just because of object-oriented thinking , Comply with the principle of data encapsulation and secure access , There is also a great advantage to whatever private The methods are implicit final!

Any private methods in a class are implicitly final.

《Think In Java》

Excerpt from 《Think In Java》 The first 6 Chapter

By final Modifying methods can increase inline inline The possibility of

Method inline is to put the caller function code " Copy " Inside the caller function , Execute as part of your own code , Reduce the overhead caused by function calls , namely JIT Optimize .

The pseudocode is as follows :

public int sum(int a, int b, int c, int d){
    return add1(a, b) + add2(c, d);
}

private int add1(int a, int b){
    return a + b;
}

private int add2(int c, int d){
    return c + d;
}

The inline code :

public int sum(int a, int b, int c, int d){
    return a + b + c + d;
}

Why method inlining improves performance ?

As we all know, function call is actually on the stack stack The operation of , That is, the process of stack pressing and stack releasing , When a method is called , A new stack frame will be added to the top of the stack , The allocated local variables and parameters will be stored in this stack frame , Then jump to the target method code execution , When the method returns , Local methods and parameters are destroyed , The top of the stack is removed , Finally return to the original address to execute .

So function calls need to have a certain amount of time and space overhead , When a method is small , But it is frequently called , This time and space costs will become relatively large , It's very uneconomical , It will reduce the performance of the program . According to the principle of 28 ,80% In fact, the performance consumption of 20% On the code of , It can improve the overall performance of the system .

But trigger method inlining is conditional , It's not that it's added final Modification can trigger inline immediately , It also needs to be based on JVM Parameters of :-XX:CompileThreshold Determine the number of compilations ,-XX:MaxFreqInlineSize Limited by the size of the inline method body .

So the business scenario where methods can be inlined is :

For frequently called hot methods , And the method body is not big , It is recommended to use final modification (private Methods are implicitly specified final Modifier , So there's no need to specify final Modifier ).

Two . public It is suggested that final Modifier

Based on the first one above , How to meet the above business scenarios , The reason as above , Good for JIT Optimize . Of course, you can also modify the class where the method is located , such final Class of is not allowed to be inherited , And all methods of this class are by default final Of .

Here's a proviso : And not being Spring AOP Proxy method

3、 ... and . Able to use lambda Do not use anonymous inner classes to implement expressions

lambda Expressions are not just grammatical sugars , It's compiled class The file in jvm The instructions executed in are also different , The instructions used are invokeDynamic, Compared with anonymous inner class, the cost of calling inner class is smaller , Because it has no initialization of anonymous inner classes , The code is also more concise .

Anonymous inner class writing :

private static final ExecutorService thredPool = Executors.newCachedThreadPool();
thredPool.submit(new Runnable() { 
    @Override
    public void run() {
        //  Business logic 
    }
});

lambda Expression writing :

private static final ExecutorService thredPool = Executors.newCachedThreadPool();
thredPool.submit(() -> {
    //  Business logic 
});

Four . Try not to call global variables frequently in a method

In class , Member variables ( Global variables ) Keep it in the pile Heap in , Local variables within a function ( Basic types 、 Parameters 、 References to objects ) It's all stored in the stack Stack in , Accessing your own variables inside a function is certainly faster than accessing variables outside the function , So it is slower to operate the data in the heap from the stack .

The code example is as follows ( Counter example ):

private int result = 0; //  Member variables 
public void sum(int... i){
    for (int j : i) {
        result += j; //  Frequent operation of member variables outside the function result
    }
}

The modified code :

private int result = 0; //  Global variables 
public void sum(int... i){
    int temp = 0; //  Temporary variable 
    for (int j : i) {
        temp += j; //  Manipulate the temporary variables inside the function 
    }
    result = temp; //  Reduce access to member variables 
}

5、 ... and . In optimizing set operations contains Again get Writing

We often encounter in our code to determine whether this element exists in the collection , There are business scenarios in which values are retrieved , The pseudocode is as follows :

public void setOrderPrice(Order order, Map<String, Price> map){
    if(map.containsKey(order.getId())){
        order.setPrice(map.get(order.getId()));
    } else {
        order.setPrice(new Price());
    }
}

In fact, you can call get obtain , And then it's empty , This saves a search for a match , Revised as follows :

public void setOrderPrice(Order order, Map<String, Price> map){
    Price price = map.get(order.getId(); //  Call directly get
    if(price != null){
        order.setPrice(price);
    } else {
        order.setPrice(new Price());
    }
}

The above is only the author who has been in Java Working insights on developing performance , Performance optimization takes time 、 efficiency 、 The trade-off between readability and readability , choose , Don't take the above as a dogma , Active learning and flexible application , Flexibility is appropriate. .

Source of the article :http://javakk.com/197.html

版权声明
本文为[Java old K]所创,转载请带上原文链接,感谢

Scroll to Top