基础知识学习笔记（二）

一、Java GC （Garbage Collection）算法总结：

1、 引用计数：

为每一个对象都设置一个计数器，计数器记录了对该对象的活跃引用的数量，如果计数器为0，则说明这个对象没有被任何变量所引用，即应该对其进行垃圾处理。

收集过程如下：

1、减少对该对象所引用的对象的计数器的值

2、 将其放入延迟收集队列中

2、标记请出收集器：

收集过程如下：

1、首先停止所有工作，从根集遍历所有的被引用的节点，然后对其进行标记，最后恢复所有工作

2、收集阶段会收集那些没有被标记的节点，然后返回空闲链表

缺点：标记阶段和清除阶段都非常耗时间。

3、拷贝收集器：

1、内存分为两个区，一个为from space，一个为 to space ，所有对象分配内存都放在from space中

2、开始清理时，把所有标记为活动的对象,copy到to space中，清空from space，互换两个内存的身份，每次清理
都重复这一步骤

缺点：浪费很大的空间。

4、标记整理收集器：

1、标记阶段：和标记清除收集器的标记阶段一样

2、整理阶段：将所有标记的对象放到堆的底部。

5、generation算法(Generational Collector) 
    
(1)young generation 

 
   年轻代分三个区。一个Eden区，两个Survivor区。大部分对象在 Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor区也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制到tenured generation。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。 

 
   young generation的gc称为minor gc。经过数次minor gc，依旧存活的对象，将被移出young generation，移到tenured generation 

  
  (2)tenured generation 

  
  生命周期较长的对象，归入到tenured generation。一般是经过多次minor gc，还 依旧存活的对象，将移入到tenured generation。（当然，在minor gc中如果存活的对象的超过survivor的容量，放不下的对象会直接移入到tenured generation） 

tenured generation的gc称为major gc，就是通常说的full gc。 

   
采用compactiion算法。由于tenured generaion区域比较大，而且通常对象生命周期都比较长，compaction需要一定时间。所以这部分的gc时间比较长。 

   
minor gc可能引发full gc。当eden＋from space的空间大于tenured generation区的剩余空间时，会引发full gc。这是悲观算法，要确保eden＋from space的对象如果都存活，必须有足够的tenured generation空间存放这些对象。 

 (3)permanent
generation 

   
该区域比较稳定，主要用于存放classloader信息，比如类信息和method信息。 

对于spring hibernate这些需要动态类型支持的框架，这个区域需要足够的空间。(这部分空间应该存在于方法区而不是heap中)。 

参考 http://blog.csdn.net/eric_sunah/article/details/7866975 http://speed847.iteye.com/blog/373278
二、Linux下5中IO模型

   1)阻塞I/O（blocking I/O）
2)非阻塞I/O （nonblocking I/O）
3) I/O复用(select 和poll) （I/O multiplexing）**不是很明白这个
4)信号驱动I/O （signal driven I/O (SIGIO)）
5)异步I/O （asynchronous I/O (the POSIX aio_functions)）

参考  http://blog.csdn.net/jay900323/article/details/18141217
三、MVC模式

model：模型，主要是对于数据库的操作。

view： 视图，即可以看到的网页，或者GUI界面

controller：控制器，接收View的数据，并操作model，控制数据库，实现交互

四、threadLocal,synchronized,volatile

volatile：提示系统该关键字声明的变量可能会被其他的线程所修改，所以每次读取的时候都必须从内存中读取，不可以从线程的cache中读取。但是volatile无法和锁相比。volatile仅仅是从内存中拷贝了该变量进入线程栈中。但是内存中的变量依然存在，依旧可以被读写，只有当线程完成对拷贝的变量操作后，才重新将修改后的变量存入内存中，但是在线程修改的过程中，内存的变量依旧存下

synchronized：锁机制。对某个方法或者某个代码块加锁，实现线程同步，同一时间内只能令一个线程进行操作。

threadLocal：threadLocal类为每一个线程都维护了一个自己独有的变量拷贝。每个线程都有自己独立的变量，线程间的竞争被彻底消除，就没有必要进行线程间同步了。每个线程都有自己的独有的变量拷贝，变量被彻底的封闭在每一个线程中，并发错误的可能被彻底消除，比起synchronized，是一种以空间换取线程安全的策略。

当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

class TT extends Thread{
int b=100;
public synchronized void m1(){
System.out.println("b="+b);
try{
Thread.sleep(5000);
}catch(Exception e){
e.printStackTrace();
}
b=1000;

System.out.println("b="+b);
}

public synchronized void m2(){
b=2000;
try{
Thread.sleep(5000);
}catch(Exception e){
e.printStackTrace();
}
}

public void run(){
try{
m1();
}catch(Exception e){
e.printStackTrace();
}
}
}

public class SynchronizedTest {
public static void main(String[] args){
TT tt = new TT();
tt.start();
tt.m2();
System.out.println(tt.b);
}
}

每一个线程都设置了一个本身的threadLocal变量。互相不会被改变

package reflectionTest;

public class Threadlocal {

public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>(){

@Override
protected Integer initialValue() {
// TODO Auto-generated method stub
return 0;
}

};

public static void main(String[] args){
Thread[] thread = new Thread[5];
for(int i = 0 ;i<5;i++){
thread[i]=new Thread(new Runnable(){

@Override
public void run() {
// TODO Auto-generated method stub
int num = local.get();
for (int i = 0; i < 5; i++) {
num++;
}
//重新设置累加后的本地变量
local.set(num);
System.out.println(Thread.currentThread().getName() + " : "+ local.get());
}

}, "Thread-" + i);

}
for(Thread t : thread){
t.start();
}
}
}

参考：http://my.oschina.net/lichhao/blog/111362
http://bbs.csdn.net/topics/340062872