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