进程
linux中也称为task,是系统分配资源的基本单位
资源:独立的地址空间 内核数据结构(进程描述符…)全局变量 数据段…
进程描述符:PCB(Process Control Block)
线程
线程在linux中的实现:
《linux内核设计与实现》第三版28页讲到:
线程就是一个普通进程,只不过和其他进程共享资源(内存空间 全局数据等…)
其他系统都有各自的所谓LWP的实现 Light Weight Process
高层面理解:一个进程中不同的执行路线
面试高频:进程和线程有什么区别?
答案:进程就是一个程序运行起来的状态,线程是一个进程中的不同的执行路径。
专业点说:进程是OS分配资源的基本单位,线程是执行调度的基本单位。分配资源最重要的是:独立的内存空间,线程调度执行(线程共享进程的内存空间,没有自己独立的内存空间)
纤程
纤程:用户态的线程,线程中的线程,切换和调度不需要经过OS
优势:
1:占有资源很少 OS : 线程1M Fiber:4K
2:切换比较简单 3:启动很多个10W+
Java中对于纤程的支持:没有内置,可以利用第三方库Quaser(并不成熟)
<dependency>
<groupId>co.paralleluniverse</groupId>
<artifactId>quasar-core</artifactId>
<version>0.8.0</version>
</dependency>
案例:
使用线程的模式:
import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.SuspendableRunnable;
public class HelloFiber {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
Runnable r = new Runnable() {
@Override
public void run() {
calc();
}
};
int size = 10000;
Thread[] threads = new Thread[size];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(r);
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
for (int i = 0; i < threads.length; i++) {
threads[i].join();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
static void calc() {
int result = 0;
for (int m = 0; m < 10000; m++) {
for (int i = 0; i < 200; i++) result += i;
}
}
}
使用纤程的模式:
import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;
import co.paralleluniverse.strands.SuspendableRunnable;
public class HelloFiber2 {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
int size = 10000;
Fiber<Void>[] fibers = new Fiber[size];
for (int i = 0; i < fibers.length; i++) {
fibers[i] = new Fiber<Void>(new SuspendableRunnable() {
public void run() throws SuspendExecution, InterruptedException {
calc();
}
});
}
for (int i = 0; i < fibers.length; i++) {
fibers[i].start();
}
for (int i = 0; i < fibers.length; i++) {
fibers[i].join();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
static void calc() {
int result = 0;
for (int m = 0; m < 10000; m++) {
for (int i = 0; i < 200; i++) result += i;
}
}
}
纤程 适用于:很短的计算任务,不需要和内核打交道,并发量高!
僵尸进程 孤儿进程
什么是僵尸线程
父进程产生子进程后,会维护子进程的一个PCB结构,子进程退出,由父进程释放如果父进程没有释放,那么子进程成为一个僵尸进程
什么是孤儿线程
子进程结束之前,父进程已经退出,孤儿进程会成为init进程的孩子,由1号进程维护
进程调度
CFS调度策略:Completely Fair Scheduler
按优先级分配时间片的比例,记录每个进程的执行时间,如果有一个进程执行时间不到他应该分配的比例,优先执行
中断
硬件跟操作系统内核打交道的一种机制
软中断(80中断) == 系统调用
系统调用:int 0x80 或者 sysenter原语
通过ax寄存器填入调用号
参数通过bx cx dx si di传入内核
返回值通过ax返回
java读网络 – jvm read() – c库read() - > 内核空间 -> system_call() (系统调用处理程序)-> sys_read()
内存管理
DOS时代 - 同一时间只能有一个进程在运行(也有一些特殊算法可以支持多进程)
windows9x - 多个进程装入内存 1:内存不够用 2:互相打扰
为了解决这两个问题,诞生了现在的内存管理系统:虚拟地址->分页装入 ->软硬件结合寻址
分页(解决内存不够用),内存中分成固定大小的页框(4K),把程序(硬盘上)分成4K大小的块,用到哪一块,加载那一块,加载的过程中,如果内存已经满了,会把最不常用的一块放到swap分区, 把最新的一块加载进来,这个就是著名的LRU算法
LR:Least Recently Used 最不常用
哈希表(保证 查找操作O(1)) + 链表 (保证 排序操作和新增操作 O(1)))
双向链表 (保证 左边指针 指向右边块)
虚拟内存(解决相互打扰问题)
DOS Win31 … 互相干掉
为了保证互不影响 - 让进程工作在虚拟空间,程序中用到的空间地址不再是直接的物理地址,而是虚拟的地址,这样,A进程永远不可能访问到B进程的空间
虚拟内存好处:
隔离应用程序
– 每个程序都认为自己有连续可用的内存
– 突破物理内存限制
– 应用程序不需要考虑物理内存是否够用,是否能够分配等底层问题
安全
– 保护物理内存,不被恶意程序访问
内存地址映射:
虚拟空间多大呢?寻址空间 - 64位系统 2 ^ 64,比物理空间大很多 ,单位是byte站在虚拟的角度,进程是独享整个系统 + CPU
内存映射:偏移量 + 段的基地址 = 线性地址 (虚拟空间)
线性地址通过 OS + MMU(硬件 Memory Management Unit)
缺页中断(不是很重要):
需要用到页面内存中没有,产生缺页异常(中断),由内核处理并加载
内核同步机制
临界区(critical area): 访问或操作共享数据的代码段 ,简单理解:synchronized大括号中部分(原子性)
竞争条件(race conditions)两个线程同时拥有临界区的执行权
数据不一致:data unconsistency 由竞争条件引起的数据破坏
同步(synchronization)避免race conditions
锁:完成同步的手段(门锁,门后是临界区,只允许一个线程存在),上锁解锁必须具备原子性
原子性(象原子一样不可分割的操作)
有序性(禁止指令重排)
可见性(一个线程内的修改,另一个线程可见)
互斥锁 排他锁 共享锁 分段锁
内核同步常用方法
1.原子操作 – 内核中类似于AtomicXXX,位于<linux/types.h>
2.自旋锁 – 内核中通过汇编支持的cas,位于<asm/spinlock.h>
3.读-写自旋 – 类似于ReadWriteLock,可同时读,只能一个写
读的时候是共享锁,写的时候是排他锁
4.信号量 – 类似于Semaphore(PV操作 down up操作 占有和释放)
重量级锁,线程会进入wait,适合长时间持有的锁情况
5.读-写信号量 – downread upread downwrite upwrite
(多个写,可以分段写,比较少用)(分段锁)
6.互斥体(mutex) – 特殊的信号量(二值信号量)
7.完成变量 – 特殊的信号量(A发出信号给B,B等待在完成变量上)
vfork() 在子进程结束时通过完成变量叫醒父进程 类似于(Latch)
8.BKL:大内核锁(早期,现在已经不用)
9.顺序锁(2.6): – 线程可以挂起的读写自旋锁
序列计数器(从0开始,写时增加(+1),写完释放(+1),读前发现单数,
说明有写线程,等待,读前读后序列一样,说明没有写线程打断)
10.禁止抢占 – preempt_disable()
11.内存屏障 – 见volatile