Java总结

字符串

java字符串使用＋进行拼接时，编译器会通过StringBuilder进行优化。但是在循环体中使用+=的时候会创建多个StringBuilder，可以在循环体外显式使用StringBuilder，可以使得程序效率更高
Buffer是线程安全的，所以在单线程的情况先执行效率低于Builder

单例的写法

单例一般有两种写法，也将其称为恶汉式和懒汉式，我这里说的是在没有 lazy load 等考虑的情况下
没有带参数的写法：

public class Singleton {
    public static final Singleton INSTANCE = new Singleton();

    private Singleton(){}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

带参数的写法：

public class Singleton {
    private volatile static Singleton sInstance;
    private static final Object LOCK = new Object();

    private Singleton(Param param){
        // do some init
    }

    public static Singleton getInstance(Param param) {
        if (sInstance == null) {
            synchronized (LOCK) {
                if (sInstance == null) {
                    sInstance = new Singleton(param);
                }
            }
        }
        return sInstance;
    }
}

关于为何需要双重判空网上有很多介绍的文章，这里不再多说，需要注意的是需要使用volatile防止重排序问题

this逃逸

this逃逸主要指在构造方法没有执行完毕的情况下，其他线程获取到了这个对象的引用。需要小心在构造方法中不要使用一些异步手段将this对象发布出去。

并发多线程相关

使用 synchronized 关键字同步对象的时候应该在使用对象的地方都使用 synchronized来包裹，否则没有同步效果
将不可变的对象用 final 来修饰可以减少很多同步的问题。final并不表示对象的内容不会变化，只是说不能再赋值。相当于一个指针指向的地址确定了，但是内容没有限制
正确的中断线程：

class MyThread extends Thread {

    public void run() {
        try {
            doSomeThing();
        } catch (InterruptedException e) {
            doCancel();
        }
    }

    public void cancel() {
        interrupt();
    }
}

还有一种方法是通过在 cancel 方法中设置标志位来取消线程也是可以的，注意将标志位设置为 volatile 并且正确的处理中断

线程池的设置：线程池有三种，计算密集线程池、IO线程池，newThread(考虑到有可能希望某个任务及早执行而不是在线程池中排队)。其中计算密集型线程池的大小建议为$N(cpu核数)+1$，具体参见 《Java并发编程实战》 8.2 设置线程池大小
线程如果在处理不可打断的任务，应该在出现中断的时候将中断状态保存起来，然后在任务执行完了之后，再响应中断

class MyThread extends Thread {
    private volatile boolean interrupted = false;
    public void run() {
        try {
            while (true) {
                try {
                    doSomeThing();
                } catch (InterruptedException e) {
                    interrupted = true;
                }
            }
        } finally {
            if (interrupted)
                Thread.currentThread().interrupted();
        }
    }
    public void cancel() {
        interrupted = true;
    }
}

Thread#join() 方法可以让当前线程等待目标线程执行结束，如果目标线程已经结束，则执行当前线程后面的代码，否则必须等待目标线程结束之后（如果设置了超时时间，超时和目标线程结束两个条件满足一个即可）能执行后面的代码。使用join()方法解决定时任务提前结束引起的一些问题，具体参见 《Java并发编程实战》 7.1.4 示例：计时运行

static

使用private static编译器会优先考虑将方法内联
无论实例化几次或者调用几次方法,static代码段都执行一次...比如,你创建了类的两个实例,但是只有创建第一个实例的时候static代码段才被执行.创建第二个的时候将不执行...使用类名调用静态方法也同理
在实例化一个对象的时候也被调用.而且先于构造函数被调用.也就是说,我们创建一个对象,那么首先先调用static代码段,然后再调用构造函数

强引用、弱引用、软引用、虚引用

强引用

强引用是使用最普遍的引用。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题

Object o=new Object();   //  强引用

软引用

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

String str=new String("abc");                                     // 强引用
SoftReference softRef=new SoftReference(str);     // 软引用

弱引用

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

String str=new String("abc");    
WeakReference abcWeakRef = new WeakReference(str);
str=null;

虚引用

虚引用顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
几种引用方式在垃圾回收时候的区别

Java中父类与子类中静态代码段、非静态代码段和构造方法的执行过程

执行流程为：
父类静态代码段->子类静态代码段->父类非静态代码段->父类构造方法->子类非静态代码段->父类构造方法
在子类的构造方法执行前必然会执行父类的构造方法，如果指明了super(params)，则执行父类中对应的构造方法，否则执行默认没有参数的构造方法
参考：

http://blog.csdn.net/mazhimazh/article/details/19752475