volatile关键字：
volatile只保证变量的可见性
使用volatile关键字标示的变量也不一定是线程安全的，比如和非volatile的变量共同参与不变约束，比如运算结果依赖当前变量的值
即使编译出来的字节码只有一行，也不能代表这条字节码指令是原子的
volatile禁止指令优化重排序
多核CPU需要通过内存屏障指令来保证指令执行顺序

Java内存模型允许虚拟机对64位数据类型（long&double)的读写操作划分为两次32位操作进行，即不保证load、store、read和write的原子性，这就是所谓的非原子性协定。

实际上虚拟机的实现中，一般保证了long和double的原子性操作

符合Java happens-before 先行发生原则的操作序列，则不需要任何同步手段即可保证线程安全

线程实现：

1. 基于内核线程（使用内核线程高级接口 LWP， 轻量级进程），LWP与内核线程是1：1. 这种模式下，所有的线程操作都需要系统调用（需要再user mode和kernel mode之间切换）来完成，代价颇高，因而支持的数量有限。
2. 基于用户线程实现。 直接在用户态中完成，不需要切换到内核态。和进程之间可以实现1：N的对应。缺点就是无法利用系统内核，实现复杂，代价大。
3. 用户进程+LWP 混合实现N:M的对应关系. (P380)

线程安全：
当多个线程访问一个对象的时候，如果不考虑这些线程在运行时环境下的调度和交替执行，也不需要额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象的线程就是安全的。
-- Brian Goetz

synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或者class对象来作为锁对象。

synchronized的锁为非公平锁，ReentrantLock默认也是非公平锁，可以通过带bool值的构造函数来要求使用公平锁。（公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁)

上述都是互斥同步，也即阻塞同步

避免阻塞，可以使用自旋（锁）

在编译阶段，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。

常见配置汇总

堆设置
-Xms:初始堆大小
-Xmx:最大堆大小
-XX:NewSize=n:设置年轻代大小
-XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
-XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
-XX:MaxPermSize=n:设置持久代大小
收集器设置
-XX:+UseSerialGC:设置串行收集器
-XX:+UseParallelGC:设置并行收集器
-XX:+UseParalledlOldGC:设置并行年老代收集器
-XX:+UseConcMarkSweepGC:设置并发收集器
垃圾回收统计信息
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-Xloggc:filename
并行收集器设置
-XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
-XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
-XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
并发收集器设置
-XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
-XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。

新生代的划分：

SUN/Oracle 的HotSpot JVM 又把新生代进一步划分为3个区域：一个相对大点的区域，称为”伊甸园区(Eden)”；两个相对小点的区域称为”From 幸存区(survivor)”和”To 幸存区(survivor)”。按照规定,新对象会首先分配在 Eden 中(如果新对象过大，会直接分配在老年代中)。在GC中，Eden 中的对象会被移动到survivor中，直至对象满足一定的年纪(定义为熬过GC的次数),会被移动到老年代。

基于大多数新生对象都会在GC中被收回的假设。新生代的GC 使用复制算法。在GC前To 幸存区(survivor)保持清空,对象保存在 Eden 和 From 幸存区(survivor)中，GC运行时,Eden中的幸存对象被复制到 To 幸存区(survivor)。针对 From 幸存区(survivor)中的幸存对象，会考虑对象年龄,如果年龄没达到阀值(tenuring threshold)，对象会被复制到To 幸存区(survivor)。如果达到阀值对象被复制到老年代。复制阶段完成后，Eden 和From 幸存区中只保存死对象，可以视为清空。如果在复制过程中To 幸存区被填满了，剩余的对象会被复制到老年代中。最后 From 幸存区和 To幸存区会调换下名字，在下次GC时，To 幸存区会成为From 幸存区。

PRODUCER-CONSUMER Problem:

public interface IStorage {
void produce();
void consume();
}

import java.util.ArrayList;
import java.util.List;

public class Storage implements IStorage{

private final int MAX_COUNT;
private final List<Good> l;

public Storage(int maxCount){
    MAX_COUNT = maxCount <=0?10:maxCount;
    l = new ArrayList<Good>(MAX_COUNT);
}

public void produce(){
    synchronized(l){
        while(l.size() == MAX_COUNT){
            System.out.println("Storage is full! Waiting for consuming...");
            try {
                l.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        l.add(new Good(l.size()));
        System.out.println("Current size[P]:"+l.size());
        l.notifyAll();
    }
}

public void consume(){
    synchronized(l){
        while(l.size() == 0){
            System.out.println("Storage is empty! Waiting for producing");
            try {
                l.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        l.remove(0);
        System.out.println("Current size[C]:"+l.size());
        l.notifyAll();
    }
}

}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CStorage implements IStorage {

private final int MAX_COUNT;
private final List<Good> l;
private final Lock lock;
private final Condition signal;

public CStorage(int maxCount){
    MAX_COUNT = maxCount<=0?10:maxCount;
    l = new ArrayList<Good>(MAX_COUNT);
    lock = new ReentrantLock(true);
    signal = lock.newCondition();
}

@Override
public void produce() {
    lock.lock();
    while(l.size() == MAX_COUNT){
        System.out.println("Storage is full! Waiting for consuming...");
        try {
            signal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    l.add(new Good(l.size()));
    System.out.println("Current size[P]:"+l.size());
    signal.signalAll();

    lock.unlock();
}

@Override
public void consume() {
    lock.lock();

    while(l.size() == 0 ){
        System.out.println("Storage is empty! Waiting for producing");
        try {
            signal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    l.remove(0);
    System.out.println("Current size[C]:"+l.size());
    signal.signalAll();

    lock.unlock();
}

}

public class Producer implements Runnable {

private final IStorage store;

public Producer(IStorage store){
    this.store = store;
}

@Override
public void run() {
    while(true){
        store.produce();
    }
}

}

public class Consumer implements Runnable {

private final IStorage store;

public Consumer(IStorage store){
    this.store = store;
}
@Override
public void run() {
    while(true){
        store.consume();
    }
}

}

public class Main {

/**
 * @param args
 */
public static void main(String[] args) {
    //Storage store = new Storage(10);
    CStorage store = new CStorage(10);

    for(int i=0;i<5;i++){
        new Thread(new Producer(store),"P"+i).start();
    }

    for(int i=0;i<3;i++){
        new Thread(new Consumer(store),"C"+i).start();
    }
}

}

PRODUCER-CONSUMER Problem part2:

private LinkedBlockingQueue list = new LinkedBlockingQueue(MAX_COUNT);

put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。
take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。

排序算法分析：

Sort Methods | Average Time | Worst Time | Space
简单排序 O(n^2) O(n^2) O(1)
快速排序 O(nlogN) O(n^2) O(logN)
堆排序 O(nlogN) O(nlogN) O(1)
归并排序 O(nlogN) O(nlogN) O(n)
基数排序 O(d(n+rd)) O(d(n+rd)) O(rd)

几个排序算法:

 public void StraightInsertionSort(int[] arr){
    for(int i=1;i<arr.length;i++){
        if(arr[i-1]>arr[i]){
            int temp = arr[i];

            int j=i-1;
            for(;j>=0&&temp<arr[j];j--){
                arr[j+1] = arr[j];
            }

            arr[j+1] = temp;
        }
    }
}

public void shellSort(int[] arr){
    double dk = arr.length;
    int temp = 0;

    while(true){
        dk = Math.ceil(dk/2);
        int d = (int)dk;

        for(int x=0;x<d;x++){
            for(int i=x+d;i<arr.length;i+=d){
                if(arr[i-d]>arr[i]){
                    temp = arr[i];
                    int j=i-d;
                    for(;j>=0&&temp<arr[j];j-=d){
                        arr[j+d] =arr[j];
                    }

                    arr[j+d] = temp;

                }
            }
        }

        if(d==1){
            break;
        }
    }
}

public void selectionSort(int[] arr){
    for(int i=0,len=arr.length;i<len;i++){
        int temp=arr[i], position=i;
        for(int j=i+1;j<len;j++){
            if(arr[j]<temp){
                temp=arr[j];
                position=j;
            }
        }

        arr[position] =arr[i];
        arr[i] = temp;
    }
}

public void quickSort(int[] arr){
    if(arr!=null&&arr.length>0){
        quickSort(arr,0,arr.length-1);
    }
}

private void quickSort(int[] arr, int low, int high){
    if(low<high){
        int pv = partition(arr,low,high);
        quickSort(arr,low,pv-1);
        quickSort(arr,pv+1,high);
    }
}

private int partition(int[] arr, int low, int high){
    int pv = arr[low];
    while(low<high){
        while(low<high&&arr[high]>=pv){
            high--;
        }
        arr[low]=arr[high];
        while(low<high&&arr[low]<=pv){
            low++;
        }
        arr[high]=arr[low];
    }
    arr[low]=pv;

    return low;
}

ORM:

ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射.

Drawbacks:

1. 自动化意味着映射和关联管理，代价是牺牲性能
2. 面向对象的查询语言(X-QL)不能完全的屏蔽掉数据库层的设计,增加学习成本
3. 对于复杂查询，ORM仍然力不从心

OOP 四大特征 "抽象"、"封装"、"继承"、"多态"
OOP 四大原则：

1. SRP 单一职责原则： 一个类，应该仅有一个引起它变化的原因
2. 开放封闭原则： 软件实体（类、模块、函数等）应该可以扩展，但不可修改
3. 依赖倒转原则： 抽象不应该依赖细节，细节应该依赖抽象（面向接口编程）
4. 里氏代换原则： 子类型必须能够替换掉他们的父类型

AOP技术的具体实现，无非也就是通过动态代理技术或者是在程序编译期间进行静态的"织入"方式。下面是这方面技术的几个基本术语： 1、join point（连接点）：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个join point。 2、point cut（切入点）：本质上是一个捕获连接点的结构。在AOP中，可以定义一个point cut，来捕获相关方法的调用。 3、advice（通知）：是point cut的执行代码，是执行“方面”的具体逻辑。 4、aspect（方面）：point cut和advice结合起来就是aspect，它类似于OOP中定义的一个类，但它代表的更多是对象间横向的关系。 5、introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的 OP工具又将其称为mixin。

JDK动态代理：

包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException 参数说明： ClassLoader loader：类加载器 Class[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。