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指定的类，是最常使用的是一种加载器。