基础知识学习笔记（二）

一、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