\u2022Use static, final, private methods to allow inlining
\n\u2022To implement an immutable class
\n-declare all data private
\n-no setter methods
\n-set all data in the constructor only
\n-declare class final(no surclassing)
\n-clone mutable objects before returning a ref to them from a getter methods
\n-clone mutable objects provided to the constructor
\n-impl deep clone if shallow copying is not enough
\n\u2022Call super.clone() when impl clone()
\n\u2022Other tricks to impl immutability
\n-Immutable interface
\n\tbreakable by a simple cast
\n-Common interface or base class
\n\tnot breakable by cast
\n\tinterface IF{}
\n\tclass Mutable implements IF{}
\n\tfinal class Immutable
\n\t\timplements IF{}
\n-Immutable Delegation class
\n\tnot breakable by cast
\n\tuseful when can not change src
\n\u2022Do not rely on finalize() for non-mem rsc cleanup. You should impl your own public cleanup mechanism and put it in finalize() and always call super.finalize() in the finally block.
\n\u2022Use care when calling non-final methods from constructors
\n\u2022Prefer polymorphism to instanceof
\n\u2022Use instanceof only when have to
\n\tavoid ClassCastException?
\n\u2022Set object ref to null when not needed. Also could call System.gc()
\n\tRuntime rt = Runtime.getRuntime();
\n\tlong mem = rt.freeMemory();
\n\tSystem.gc();
\n\u2022Rules to follow when impl equals()
\n-check for comparison to this
\n-call super.equals() if any base class other than Object impl equals()
\n-prefer getClass() to instanceof
\n\u2022Place try\/catch blocks outside loops
\n\u2022Do not use exceptions for flow contr
\n\u2022Do throw exceptions from constructors
\n\u2022Use StringBuffer not String for concatenation
\n\u2022Minimize the cost of object creation
\n-use lazy loading
\n\u2022Guard against unused objects
\n\u2022Minimize synchronization
\n\u2022Use stack variables whenever possible
\n\u2022Uss static, final, and private methods to allow inlining
\n\u2022Do not initialize instance variables
\n\u2022Do initialize local variables
\n\u2022Use primitive types for faster and smaller code
\n\u2022for loop + get() is faster than Iterator, ListIterator, Enumeration
\n\u2022Use System.arrayCopy for copying arrays
\n\u2022Reuse objects whenever possible
\n\u2022Use lazy evaluation
\nMULTITHREADING
\n\u2022synchronization locks objects not methods or codes
\n\u2022”synchronized static” locks Class object
\n\u2022private byte[] lock = new byte[0];
\nis the cheapest object to create. It’s cheaper than Object o = new Object();
\nsynchronized(lock){
\n\t\/\/code to protect}
\n\u2022Use private data with an accessor method instead of public or protected data. Also clone the object if the accessor method returns a ref to a mutable object.
\n\u2022Aquire multiple locks in a fixed, global order to avoid deadlock
\n\u2022Prefer notifyAll to notify since notify wakes up only one random waiting thread
\n\u2022Use Specific Notification Pattern if you need to notify multiple threads in a particular order
\n\u2022Use spin locks for wait and notify
\npublic run(){
\n while(true){
\n synchronized(controller){
\n while(commands == null){\/\/not if!
\n\ttry{
\n\t\tcontroller.wait();
\n}catch(InterruptedException e){}
\n\/\/do sth with commands
\n }
\n }
\n}
\n\u2022Use wait and notifyAll instead of polling loops
\n\u2022Do not reassign object ref of a locked object
\n\u2022Do not invoke stop(corrupt data) or suspend(deadlocks) methods
\n\u2022Terminate threads through thread cooperation
\nprivate volatile boolean stop;
\npublic void run(){
\n\twhile(!stop){
\n\t\t\/\/do work…
\n\t}
\n\t\/\/clean up…
\n}<\/p>\n","protected":false},"excerpt":{"rendered":"
\u2022Use static, final, private methods to allow inlining \u2022To implement an immutable class -declare all data private -no setter methods -set all data in the constructor only -declare class final(no surclassing) -clone mutable objects before returning a ref to them … Continue reading