坦克书房

1. Absolutely! 毫无疑问！

2. Adorable! 可爱极了！

3. Amazing! 太神奇了！

4. Anytime! 随时吩咐！

5. Almost! 差不多了！

6. Awful! 好可怕啊！

7. Allow me! 让我来！

8. Baloney! 胡扯！荒谬！

9. Bingo! 中了！

BMP图像的载入可以用于纹理贴图，这里介绍这种方法。这里用到的主要是auxDIBImageLoad函数，来自glaux.h库。所以在程序中一定要加上#include <GL\glaux.h>在工程中也要加载相关的.lib文件。代码加了注释，应该可以看懂。 

　　最近在看书，也在网上接触各种技术，自己的基础在一天一天地成长，希望有一天能长得根壮冠粗，好结出硕果。

　　看了不少东西，但实践不是太多。所以也没有什么可以拿得出手的，故也没往自己的博客上放。书看了，也没有总结，所以也没有什么心得笔记可以拿出来与别人分享。

　　之与半瓶水拿出来秀，倒不如装满了倒之与人。

　　写博客不久，自然和老手不能相提并论。但我想，博客一半是别人看，一半是自己看。首先是自己看，如果自己都没有看懂，拿出来秀，未免不太好。上次我贴出SRGP的一些...

如题

Bus的工作还是不错的。终于不用给出什么第三方不完美解决方案了。

后台的风格和功能似乎也很不错，淡淡的背景使人更关注正在编辑的文字。自动保存功能实用极了。 

Good Job, Bus! 

...

Java复习

重点：
>> 所有Java关键字都是小写的，TURE、FALSE、NULL等都不是Java关键字
>> Java字符采用Unicode编码，每个字符占两个字节
>> Java浮点类型常量有两种表示形式    3.14 314.0 .314 或3.14e2 3.14E2 314E2
>> Java浮点型常量默认为double型
>> 引用类型变量的值是某个对象的句柄，而不是对象本身
>> 声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象
>> Java也不能完全防止if(bool i = true){//...}错误的产生；但是Java可以解决这样的问题if(Int = 3){//...}因为Java的if里只能接收boolean
>> 在switch语句里别忘了break和default，switch只能接收byte short char int
>> Java的三类循环语句for/ while/ do while
>> 在数组中不能进行类型提升
         int [ ] a;
         int [ ] b = new int [4];
         char [ ] c = new char [5];
         a = b;
         a = c；//ERROR
>> 数组的初始化有两种方式：动态和静态
>> 每个数组都有一个属性length指明它的长度
>>
         int[][] tt = new int[4][];
         tt[0] = new int[2];
         tt[1] = new int[4];
         tt[2] = new int[6];
         tt[3] = new int[8];

>> int intArray[][] = {{1,2},{2,3},{3,4,5}};
   int intArray1[3][2] = {{1,2},{2,3},{4,5}};  //illegal
>> 当复制大量数据时，使用System.arraycopy()命令, 优化JAVA程序开发，提高JAVA性能
----> arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

>>
重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型
重写方法不能使用比被重写方法更严格的访问权限
public class Parent {
 public void method1() {}
}
public class Child extends Parent {
 private void method1() {}  //illegal
}

>>
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造方法中调用父类的构造方法
super的追溯不仅于直接父类

>>
// student.java:
class Person{
 ...
}
class Student extends Person {
 ...
 public static void main (String args[]){
  Person p = new Person ("Liming",50);
  Student s = new Student ("Wangqiang",20,"PKU");
  Person p2 = new Student ("Zhangyi",18,"dlut");
  Student s2 = (Student) p2;
 }
}

>>
一个对象只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
  Person p = new Student();
  Object o = new Person();
  o = new Student();
>>声明是父类型的，但指向子类型，那么子类型的一些域就不可以使用
 Student m = new Student();
 m.school = "dlut";    //合法
 Person e = new Student();
 e.school = "dlut";    //非法
>> 虚拟方法调用(多态情况下)
class TestVirtualInvoke{
 
 static void doStuff(Shape s){
  s.draw();
 }
 
 public static void main (String[]args){
  Circle c = new Circle();
  Triangle t = new Triangle();
  Line l = new Line ();
  doStuff(c);
  doStuff(t);
  doStuff(l); 
 }
}
class Shape {
 void draw (){ System.out.println("Shape drawing."); }
}
class Circle extends Shape {
 void draw (){ System.out.println("Draw Circle."); }
}
class Triangle extends Shape {
 void draw (){ System.out.println("Draw Triangle."); }
}
class Line extends Shape {
 void draw (){ System.out.println("Draw Line."); }
}

>> 对象数据类型的转型
损失为“精度”—— “数据域”（属性和方法）

>>
  同类收集( homogenous collections)

 MyDate[] m = new MyDate[2];
 m[0] = new MyDate(22, 12, 1964);
 m[1] = new MyDate(22, 7, 1964);

  异类收集(heterogeneous collections)

 Person [] p= new Person[3];
 p[0] = new Student();
 p[1] = new Person();
 p[2] = new Graduate();

>> 继承的诡计
public class TestHeritate{
 public static void main (String[] args){
  Base b = new Subclass();
  System.out.println(b.x);
  System.out.println(b.method());
 } }

class Base{
 int x = 2;
 int method(){ return x; }
}

class Subclass extends Base{
 int x = 3;
 int method (){ return x ; }
}
// 结果是
2
3

访问一个引用型的变量的非静态方法，运行时与实际引用的对象的方法绑定。
访问一个引用型的变量的成员变量（包括静态变量和实例变量），运行时与声明的类的成员变量绑定。
访问一个引用型的变量的静态方法，运行时与声明的类的方法绑定。

>> instanceof 关键字 确定对象类型
class InstanceOf {
 public static void main (String[] args){
  Object [] things = new Object [3];
  things [0] = new Integer (4);
  things [1] = new Double (3.14);
  things [2] = new Double (2.09);
  double s = 0;
  
  for (int i=0; i< things.length; i++){
   if (things[i] instanceof Integer)
     s += ((Integer)things[i]).intValue();
   else if (things[i] instanceof Double)
     s += ((Double)things[i]).doubleValue();
  } 
  System.out.println("sum="+s);
 }
}
>> 对Java对象的强制类型转换称为造型
在造型前可以使用instanceof操作符测试一个对象的类型
从子类到父类的类型转换可以自动进行
Object o = new Child();
从父类到子类的类型转换必须通过造型(强制类型转换)实现
Child child;
Parent parent = new Parent();
child = (Child)parent;

无继承关系的引用类型间的转换是非法的
如两个数组间的转换,如从int[]到char[]

>>
this(argument_list) 可以调用父类的构造方法
super(argument_list)语句调用父类的构造方法

>> super的使用有三种情况：
用来访问父类被隐藏的成员变量，如：super.variable
用来调用父类中被重写的方法，如：super.Method ( [paramlist] )；
用来调用父类的构造函数，如：super( [paramlist] )；
>> this的使用也有三种情况，类似

>> 在子类构造函数中，调用了父类的构造函数，而在父类的构造函数中调用了一个被子类覆盖的方法，此时，这个方法会被子类覆盖。发生错误
所以设计构造函数的时候要尽可能地简洁。
>> static块通常用于初始化static (类)属性
class Person {
 public static int total;
 static {
         total = 100;//为total赋初值
 }
 …… //其它属性或方法声明
 }

>> 用static来实现Singleton
 class Single{
   private static Single onlyone = new Single();
   private String name;
  public static Single getSingle() {
    return onlyone;
   }
   private Single() {}
   }

public class TestSingle{
 public static void main(String args[]) {    Single  s1 = Single.getSingle();
    Single  s2 = Single.getSingle();
     if (s1==s2){
   System.out.println("s1 is equals to s2!");
  }
     }
}

>>
final标记的类不能被继承。
final标记的方法不能被子类重写。
final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。

>>
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。否则不能被实例化。
抽象方法只需声明，不需实现。
abstract 返回类型 函数名(参数列表)

>> abstract方法必须位于abstract类中

>> public class A{
        private int s = 111;
        public class B {
 private int s = 222;
 public void mb(int s) {
         System.out.println(s); // 局部变量s
         System.out.println(this.s); // 内部类对象的属性s
         System.out.println(A.this.s); //  外层类对象属性s
 }
       }
       public static void main(String args[]){
 A a = new A();
 A.B b = a.new B();
 b.mb(333);
        }
}

>> java.Math
Math.floor //不大于参数的最大整数
Math.ceil //  不小于参数的最小整数

>> finally
不论在try代码块中是否发生了异常事件，finally块中的语句都会被执行。

>>
equals比较“引用”是否相等
实现为
public boolean equals(Object o) { return this==o; }
改写后为比较“内容”。改写的有File、Date、String、包装类（wrapper）
comparable为比较“大小”
实现为
public interface Comparable {  public int compareTo(Object o); }

>> Object类的hashCode方法实现是将对象内存地址转换成一个整数，所以，不同对象的散列值不同。
不同的对象应该提供不同的散列值。

>> 每个基本数据类型都对应一个包装类。
如 char 有Character包装类

>> 数学运算全部都是静态方法
故使用时可以这样做
Math.abs(XX)

>> Java GUI
1、提供了一些容器组件，用来容纳其他的组件
2、用布局管理器来管理组件在容器上的布局
3、利用监听接口或适配器来响应各种事件，实现界面与用户的交互。
4、提供了一套绘图机制，来自动维护或刷新图形界面。

//------------------------------------------------------------

java.lang.Object
   |
   +----java.awt.Component
           |
           +----java.awt.Container
                   |
                   +----java.awt.Window
                           |
                           +----java.awt.Frame

//-------------------------------------------------------------

//-------------------------------------------------------------

java.lang.Object
   |
   +----java.awt.Component
           |
           +----java.awt.Container
                   |
                   +----java.awt.Panel

//-------------------------------------------------------------

>> 布局管理器
BorderLayout、FlowLayou

操作系统词汇

并行系统：parallel system
操作系统：operating system
超文本：hypertext
城域网：metropolitan-area network, MAN
存储器：memory
存储区域网络：storage-area network, SAN
大型计算机：mainframe
大型计算机系统：mainframe computer system
对称多处理：symmetric multiprocessing, SMP
对等网络：Peer-to-Peer
对等网络系统：Peer-to-Peer system
多处理机系统：multiprocessor system
多道程序设计：multiprogramming
多路复用信息与计算服务：MULTIplexed Information and Computing Service, MULTICS
多任务处理：multitasking
非对称多处理：asymmetric multiprocessing
分布式锁定管理：distributed lock manager, DLM
分布式系统：distributed system
分时：time sharing
分时系统：time-shared system
辅助存储器（二级存储器）：secondary storage
高可用性（高效率）：high availability
个人工作站：personal workstation
个人计算机：personal computer, PC
个人数字助理：personal digital assistant, PDA
工作站：workstation
功能退化，故障弱化：graceful degradation
广域网：wide-area network，WAN
环球网：World Wide Web, WWW
集群系统：clustered system
计算服务系统：compute-server system
交互式计算机系统：interactive computer system
紧密耦合系统：tightly coupled system
进程：process
局域网：local-area networks，LAN
客户端／服务器系统：client-server system
控制程序：control program
蓝牙：BlueTooth
内核：kernel
批处理系统：batch system
容错：fault tolerant
入口：portal
软件：software
软实时系统：soft real-time system
实时系统：real-time system
手持系统：handheld system
输入输出设备：input/output (I/O) device
松散耦合系统：loosely coupled system
图形用户界面：graphic user interface, GUI
网络：network
网络操作系统：network operating system
网络计算机：network computer
文件服务系统：file-server system
物理内存（物理存储器）：physical memory
响应时间：response time
小范围网络：small-area network
小型计算机：minicomputer
异步传输模式：Asynchronous Transmission Mode, ATM
因特网：Internet
硬件：hardware
硬实时系统：hard real-time system
中央处理单元:central processing unit, CPU
资源分配程序：resource allocator
资源利用：resource utilization
作业调度：job scheduling
作业调度程序：job schedule

<h3>第七章<br /></h3>进程同步<br /><br />>>进程的同步（直接作用）synchronism<br />指系统中多个进程中发生的事件存在某种时序关系，需要相互合作，共同完成一项任务。具体说，一个进程运行到某一点时要求另一伙伴进程为它提供消息，在未获得消息之前，该进程处于等待状态，获得消息后被唤醒进入就绪态 <br /> <br />>>进程的互斥（间接作用）mutual exclusion<br />由于各进程要求共享资源，而有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥<br /><br />>>临界资源：critical resource<br />系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源或共享变量<br /><br />>>临界区（互斥区）：critical section <br /> 在进程中涉及到临界资源的程序段叫临界区，多个进程的临界区称为相关临界区<br /><br />P(s)<br />{<br /> s.value = s.value --;<br /> if (s.value < 0)<br /> {<br /> 该进程状态置为等待状态<br /> 将该进程的PCB插入相应的等待队列末尾s.queue;<br /> }<br /> }<br /><br />//----------------------------------------<br />V(s)<br />{<br /> s.value = s.value ++;<br /> if (s.value < = 0)<br /> {<br /> 唤醒相应等待队列s.queue中等待的一个进程<br /> 改变其状态为就绪态<br /> 并将其插入就绪队列<br /> }<br />}<br /><br /><br />S1初值为1，S2初值为0<br /><br />P： Q：<br />while (true) { while (true) {<br /> 生产一个产品; P(s2);<br /> P(s1) ; 从缓冲区取产品;<br /> 送产品到缓冲区; V(s1);<br /> V(s2); 消费产品;<br />}; };<br /><br />//小结：P为申请资源，V为释放资源；先P后V<br /><br />多个缓冲区的生产者和消费者<br /><br />P：<br />i = 0;<br />while (true) <br /> { <br /> 生产产品; <br /> P(S1); <br /> 往Buffer [i]放产品; <br /> V(S2); <br /> i = (i+1) % n; <br /> };<br /><br />Q：<br />j = 0;<br />while (true) <br /> {<br /> P(S2);<br /> 从Buffer[j]取产品;<br /> V(S1);<br /> 消费产品;<br /> j = (j+1) % n;<br />};<br /><br /><br />P.V操作讨论<br />1) 信号量的物理含义：<br />S>0表示有S个资源可用<br />S=0表示无资源可用<br />S<0则| S |表示S等待队列中的进程个数<br /><br />P(S):表示申请一个资源 <br />V(S):表示释放一个资源。信号量的初值应该大于等于0<br /><br />P.V操作的优缺点<br />优点：<br />简单，而且表达能力强（用P.V操作可解决任何同步互斥问题）<br />缺点：<br />不够安全；P.V操作使用不当会出现死锁；遇到复杂同步互斥问题时实现复杂<br /><br /><br /><br /><br /><br />

第四章

进程

明确进程的含义和程序和区别
明确进程包含的内容
明确并发与并行的区别
明确进程的状态及转换条件
明确进程控制块的作用及内容
明确上下文切换的过程
了解进程间通信的机制有哪些，包括单机系统和网络系统

进程
1、运行中的程序，进程的运行必须在顺序文件中？？？
2、进程包括
程序计数器（program counter）
堆栈（stack）
数据区（data section）

进程状态
1、新建
2、运行
3、等待
4、准备
5、终止

进程状态图（**见幻灯片4**）

进程控制块（PCB）
>>进程相关的信息
1、进程状态
2、程序计数器
3、CPU寄存器
4、CPU调试信息
5、内存管理信息
6、计账信息
7、I/O状态信息

PCB
_________________
|                 |  process  |
|   pointer    |   state      |
|________ |________|
|     process number     |
|_________________|
| program counter        |
|_________________|
|          registers            |
|_________________|
|       memory limits       |
|_________________|
|           list of               |
|        open files            |
|_________________|

各种进程调度队列
1、任务队列（job queue）
全部进程
2、准备队列
3、设备队列
4、进程在不同的队列中可以迁移

准备队列图（**见幻灯片9**）

进程调度示意图（**见幻灯片10**）

调度器（schedulers）
>>远程调度器（long-term scheduler）
1、选择要进入准备队列的进程
2、经常使用
>>远程调度器（short-term scheduler）
1、在准备队列中选择要执行的进程
2、不常使用
3、决定了多道程序的程度


中程调度（图**幻灯片12**）

进程分类
1、I/O-bound process -long I/O time
2、CPU-bound process -long CPU bursts

上下文切换
1、当CPU切换到另一个进程时，要保存旧进程，并加载新来进程的状态
2、上下文切换时间是一种系统开销，系统在切换上下文时不做其它有用的工作
3、切换的时间由硬件决定

进程创建
1、父进程创建子进程，如此下去，成为树
2、资源共享
父子共享所有资源
子资源共享父的子资源
不共享
3、执行
父子并发执行
父等待，直至子执行完
4、地址空间
子复写父的 ？？？
child has a program loaded into it
5、UNIX 例子 ？？？
fork:
exec:

进程结束？？？

协作进程（cooperating processes）？？？
1、独立的进程不会受其它进程执行的影响
2、协作进程会受到其它进程执行的影响
3、进程协作的好处
信息共享
计算加速
模块化
方便

生产者消费者问题（略）

进程间通信（IPC）
1、消息系统——不用借助共享变量
2、有两种操作：send(message)/receive(message)
3、条件：物理（共享内存、总线），逻辑（逻辑属性）

>>直接通信
1、进程间必须明确地指出通信对方的名字
send(P, message)——发给P
receive(Q, message)——从Q收
2、通信属性
自动连接、明确的两个对应进程、明确的一条线路、不一定直连，但一定双向

>>非直接通信
1、通过共享邮箱（mailbox）实现通信
2、通信属性
只有通过共享邮箱才能实现通信
线路不确定
线路可能不直连，可能是双向
3、send(A, message)——发信到A邮箱；receive(A, message)——从A邮箱收信

进程同步
Bocking（阻塞）——同步
Non-blocking（非阻塞）——异步

第三章

操作系统结构
明确操作系统的基本组成包含哪些部分
明确系统调用的含义
明确操作系统设计所采用的结构有哪些,各自的优缺点

常见系统组成

进程管理
主存管理
文件管理
I/O系统管理
辅存管理
网络
保护系统(protection system)
命令解释程序(Command-Interpreter System)

进程管理
1、进程是执行中的程序。进程需要CPU时间，内存，文件，I/O驱动器来完成任务
2、操作系统负责下面的进程管理
进程创建和删除
进程监视和恢复
进程并行和通信

主存管理
1、是一块字和字节的空间，每个字和字节都有自己的地址
2、主存是易失性的（volatile）
3、操作系统负责下面的主存管理
跟踪正在被使用的内存及使用对象
内存有空余时决定载入哪个进程
分配和回收内存空间

文件管理
1、文件是创建时定义的一组相关信息
2、操作系统负责下面的文件管理
文件创建和删除
目录创建和删除
Support of primitives for manipulating files and directories.
映射文件到辅存
备分到可靠的存储媒体
I/O系统管理
1、I/O包括“缓冲-快存”（buffer-caching）系统
2、通用设备驱动器接口
3、硬件驱动

辅存管理
1、主存易失、容量小，故要辅存来备份
2、现在操作系统用磁盘来作为辅存
3、操作系统主要负责下面的辅存管理
空余空间管理
存储分配
磁盘调度

网络（分布式系统）
1、分布式系统是一组不共享内存和时钟CPU
2、各个CPU通过网络连接
3、通过协议进行通信
4、分布式的好处
加速计算
增强数据可用性（data availability）
提高可靠性

保护系统
1、保护系统是一种访问控制机制，主要限制程序、进程、或用户访问系统或用户资源
2、保护机制必须做到
区分授权和未授权
specify the controls to be imposed ???
provide a means of enforcement
命令解释程序系统
>> 操作系统带的命令很多包括
1、进程创建和管理
2、I/O处理
3、辅存管理
4、主存管理
5、文件系统访问
6、保护
7、网络
>> 读取和解释控制语句的程序叫法有所不同
1、命令行解释器（command-line interpreter）
2、shell(in UNIX)
>> 命令解释程序的作用是获取和执行下一个命令

系统调用（System Calls）

1、系统调用提供了运行程序和操作系统之间的接口
2、一般都可使用汇编语言
3、一些如C/C++的高级语言代替汇编进行系统调用，进行系统编程
4、三种常见的参数传递方法
寄存器中
在内存中建表，表的地址在寄存器中当作参数传递
在椎内存中进栈和出栈
系统调用的种类
1、进程控制
2、文件管理
3、设备管理
4、信息保存（imfomation maintenace）
5、通信

MS-DOS 运行
_______________
|                             |
|   free memory       |
|                             |
|______________ |
| command             |
|          interpreter   |
|______________|
|                             |
|       kernel            |
|______________|

_______________
|                              |
|     free memory      |
|_______________|
|                              |
|                              |
|        process          |
|                              |
|_______________|
| command              |
|          interpreter    |
|_______________|
|                              |
|           kernel          |
|_______________|

UNIX 运行时的多程序
_______________
|                             |
|      process D        |
|______________ |
|   free memory       |
|______________|
|                            |
|      process C       |
|______________|
| command            |
|        interpreter    |
|------------------ |
|                            |
|        process B     |
|______________|
|                            |
|        kernel           |
|______________ |

进程通信模型
1、消息模型
_______________
|                              |
|          process        |<<\
|_______________|    | |
|                              |    | | Message1
|_______________|    | |
|                              |<<<<<\
|          process        |    | |     | |        
|_______________|    | |     | |
|                              |    | |     | |
|                              |    | |     | | Message2
|_______________|    | |     | |
|                              |<</      | |
|          kernel           |           | |
|_______________|<<<<</
2、共享内存
_______________
|                             |
|        process         |<<|\
|______________ |    | |
|    shared Mem      |<<| |
|______________ |    | |
|                             |<<|/
|        process         |
|______________ |
|                             |
|______________ |
|                             |
|            kernel        |
|______________ |
MS-DOS系统
用最小的空间实现最大的功能
1、不分模块
2、虽然有一定结构，但是接口和功能分开得不是很好

==========应用程序==============(!!SOME PROBLEMS HERE!!)
\/                                                             \/
==========系统程序====
\/
=====MS-DOS 设备驱动==
\/
==========ROM BIOS 设备驱动

UNIX系统结构
分为两部分
>>系统程序
>>内核
1、包括所有在系统调用和物理硬件之间的一切
2、提供文件系统、CPU调度、内存管理、和其它功能

分层思想（OS/2）
1、操作系统分为几个层，每个层都是建立在下一层的基础之上，0层是硬件，最高层是用户接口
2、With modularity, layers are selected such that each uses functions (operations) and services of only lower-level layers.？？？

微内核系统结构（Windows NT）
1、尽可能得从内核转移到用户空间
2、用消息传递的方式在用户模块间通信
>>好处
1、微内核易扩充
2、easier to port the operating system to new architectures？？？
3、更加可靠（运行于内核模式的代码更少）
4、更加安全

第二章

计算机系统结构

分层的存储设备:

registers            fast
      |                   /|\
cache                  |
     |                     |
main memory       |
     |                     |
electornic disk     |
     |                     |
magnetic disk      |
    |                      |
optical disk          |
    |                      |
magnetic tapes  slow

迁移历程
magnetic disk ->main memory ->cache ->hardware register

Hardware Protection（硬件保护）
1、Dual-Mode Operation
2、I/O Protection
3、Memory Protection
4、CPU Protection

Dual-Mode Operation
1）多任务的系统要求一个任务的错误不引起另一个任务错误执行
2）硬件支持两种不同模式
User mode-用户保证程序的执行
Monitor mode（kernel mode/system mode）-操作系统保证程序的执行
3）Mode位加入到硬件中：monitor(0)/user(1)
4）Privileged instructions只能在monitor模式下使用

I/O Protection
所有IO指令都是privileged instruction
不能让应用程序在moditor模式下控制计算机

System call（系统调用）？？？



Memory Protection
1、至少要保护 interrupt vector 和 interrupt service routines
2、两个寄存器：Base register -开始的内存地址；Limit register -内存地址范围
3、范围外的内存空间是受保护的


4、载入base and limit register 的指令是 privileged instruction

CPU Protection
Timer
1、一定时间间隔后中断，交还给操作系统控制权
2、每一个clock tick timer 减一，timer 到0时，中断发生
3、Timer 一般被用于分时系统
4、Timer 也被用于计算当前时间
5、Load-timer是一个privileged instruction