#include
#include
#include
int memoryStartAddress = -1;
int memorySize = -1;
struct jobList
{
int id; /* 作业ID */
int size; /* 作业大小(需要的存储空间大小)*/ int status;
/* 作业状态0 : new job ,1 : in the memory , 2 : finished . */
struct jobList *next; /* 作业链表指针*/
};
struct freeList
{
int startAddress; /* 分区起始地址*/
int size; /* 分区大小*/
struct freeList *next; /* 分区链表指针*/
};
struct usedList
{
int startAddress; /* 分区起始地址*/
int jobID; /* 分区中存放作业ID */
struct usedList *next; /* 分区链表指针*/
};
void errorMessage(void) /*出现严重错误时显示信息并结束程序*/ {
printf("\n\tError !\a");
printf("\nPress any key to exit !");
getch();
exit(1);
}
void openFile(FILE **fp,char *filename,char *mode)
/*以要求的方式打开文件*/ {
if((*fp = fopen(filename,mode)) == NULL)
{
printf("\nCan't open %s in mode %s.",filename,mode);
errorMessage();
}
}
void makeFreeNode(struct freeList **empty,int startAddress,int size)
/*根据参数startAddress、size创建空闲节点,由empty指针返回*/ {
if((*empty = malloc(sizeof(struct freeList))) == NULL)
{
printf("\nNot enough to allocate for the free node .");
errorMessage();
}
(*empty)->startAddress = startAddress;
(*empty)->size = size;
(*empty)->next = NULL;
}
void iniMemory(void) /*初始化存储空间起始地址、大小*/ {
char MSA[10],MS[10];
printf("\nPlease input the start address of the memory !");
scanf("%s",MSA);
memoryStartAddress = atoi(MSA);
printf("\nPlease input the size of the memory !");
scanf("%s",MS);
memorySize = atoi(MS);
}
char selectFitMethod(void) /*选择适应算法*/
{
FILE *fp;
char fitMethod;
do{
printf("\n\nPlease input a char as fallow to select the fit method !\ \n 1 (Best fit) \
\n 2 (Worst fit) \
\n 3 (First fit) \
\n 4 (Last fit)\n");
fitMethod = getche();
}while(fitMethod < '1' || fitMethod > '4');
openFile(&fp,"d:\\result.cl","a");
switch(fitMethod)
{
case '1':
fprintf(fp,"\n\n\n\n\tBest fit");
fprintf(fp,"\n**********************************************");
break;
case '2':
fprintf(fp,"\n\n\n\n\tWorst fit");
fprintf(fp,"\n**********************************************");
break;
case '3':
fprintf(fp,"\n\n\n\n\tFirst fit");
fprintf(fp,"\n**********************************************");
break;
case '4': fprintf(fp,"\n\n\n\n\tLast fit");
fprintf(fp,"\n**********************************************");
break;
}
fclose(fp);
return fitMethod;
}
void inputJob(void) /*从键盘输入作业到D盘的JOB文件*/
{
int /*id,size, */status = 0,jobnum = 0;
FILE *fp;
char id[10],size[10];
openFile(&fp,"d:\\job.cl","w");
fprintf(fp,"job_ID\tsize\tstatus");
printf("\n\n\n\nPlease input the jobs as fallow !\
\nEnter a integer smaller than 1 to quit .\njob_ID\tsize\n");
do{
/* scanf("%d%d",&id,&size); */
scanf("%s\t%s",id,size);
if(atoi(id) > 0 && atoi(size) > 0)
{
fprintf(fp,"\n%s\t%s\t%d",id,size,status);
/* fprintf(fp,"\n%d\t%d\t%d",id,size,status); */
jobnum++;
}
else break;
}while(1);
if(jobnum)
printf("\nFinished to input the jobs !");
else
{
printf("\nNo job was given .");
errorMessage();
}
fclose(fp);
}
int makeJobList(struct jobList **jobs)
/*从JOB文件中读出作业并创建作业链表*/ {
char jobID[10],size[10],status[10];
struct jobList *rear;
FILE *fp;
openFile(&fp,"d:\\job.cl","r");
fscanf(fp,"%s%s%s",jobID,size,status);
if((*jobs = malloc(sizeof(struct jobList))) == NULL)
{
printf("\nNot enough to allocate for the job .");
fclose(fp);
errorMessage();
}
rear = *jobs;
(*jobs)->next = NULL;
while(!feof(fp))
{
struct jobList *p;
fscanf(fp,"%s%s%s",jobID,size,status);
if((p = malloc(sizeof(struct jobList))) == NULL)
{
printf("\nNot enough to allocate for the job .");
fclose(fp);
errorMessage();
}
p -> next = rear -> next;
rear -> next = p;
rear = rear -> next;
rear -> id = atoi(jobID);
rear -> size = atoi(size);
rear -> status = atoi(status);
}
fclose(fp);
return 0;
}
int updateJobFile(struct jobList *jobs) /*更新作业链表中作业的状态*/ {
FILE *fp;
struct jobList *p;
openFile(&fp,"d:\\job.cl","w");
fprintf(fp,"job_ID\tsize\tstatus");
for(p = jobs -> next;p;p = p -> next)
fprintf(fp,"\n%d\t%d\t%d",p->id,p->size,p->status);
fclose(fp);
return 0;
}
int showFreeList(struct freeList *empty) /*空闲分区队列显示*/
{
FILE *fp;
struct freeList *p = empty -> next;
int count = 0;
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\nNow show the free list...");
printf("\n\nNow show the free list...");
if(p)
{
fprintf(fp,"\nnumber\tsize\tstartAddress");
printf("\nnumber\tsize\tstartAddress");
for(;p;p = p -> next)
{
fprintf(fp,"\n%d\t%d\t%d",++count,p -> size,p -> startAddress);
printf("\n%d\t%d\t%d",count,p -> size,p -> startAddress);
}
fclose(fp);
return 1;
}
else
{
fprintf(fp,"\nThe memory was used out !");
printf("\nThe memory was used out !");
fclose(fp);
return 0;
}
}
void getJobInfo(struct jobList *jobs,int id,int *size,int *status)
/*获取作业的信息*/ {
struct jobList *p = jobs->next;
while(p && p->id != id)
p = p->next;
if(p == NULL)
{
printf("\nCan't find the job which id is : %d .",id);
errorMessage();
}
else
{
*size = p -> size;
*status = p -> status;
}
}
void updateJobStatus(struct jobList **jobs,int id,int status)
{
struct jobList *p = (*jobs)->next;
while(p && p->id != id)
p = p->next;
if(p == NULL)
{
printf("\nCan't find the job which id is : %d .",id);
errorMessage();
}
else
p -> status = status;
}
int showUsedList(struct jobList *jobs,struct usedList *used)
/*作业占用链表显示*/
{
FILE *fp;
struct usedList *p = used -> next;
int count = 0,size,status;
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\nNow show the used list...");
printf("\n\nNow show the used list...");
if(p)
{
fprintf(fp,"\nnumber\tjobID\tsize\tstartAddress");
printf("\nnumber\tjobID\tsize\tstartAddress");
for(;p;p = p -> next)
{
getJobInfo(jobs,p -> jobID,&size,&status);
fprintf(fp,"\n%d\t%d\t%d\t%d",++count,p->jobID,size,p-> startAddress);
printf("\n%d\t%d\t%d\t%d",count,p->jobID,size,p-> startAddress);
}
fclose(fp);
return 1;
}
else
{
fprintf(fp,"\nNo job in the memory ! You should input some jobs to it.");
printf("\nNo job in the memory ! You should input some jobs to it.");
fclose(fp);
return 0;
}
}
int showJobList(struct jobList *jobs) /*显示作业链表*/
{
struct jobList *p;
p = jobs->next;
if(p == NULL)
{
printf("\nNo job in the list ! Try again next time.");
return 0;
}
printf("\n\nThe job list is as fallow :\njob_ID\tsize\tstatus");
while(p)
{
printf("\n%d\t%d\t%d",p->id,p->size,p->status);
p = p->next;
}
}
void moveFragment(struct jobList *jobs,struct freeList **empty,struct usedList **used)
{
int size,status;
struct usedList *p;
int address = memoryStartAddress;
/*全局变量,初始化时分配存储空间始址*/
if((*empty)->next == NULL) /* 空闲分区链表为空,提示并返回*/
{
printf("\nThe memory was used out at all.\nMay be you should finish some jobs first or press any key to try again !");
getch();
return;
}
for(p = (*used) -> next;p;p = p-> next)
/* 循环的修改占用分区的始址*/
{
p -> startAddress = address;
getJobInfo(jobs,p -> jobID,&size,&status);
/* 由作业ID获得作业大小*/
address += size;
}
(*empty)->next->startAddress = address;
/*修改空闲分区的首节点始址、大小*/
(*empty) -> next -> size = memorySize - (address - memoryStartAddress);
(*empty) -> next -> next = NULL;
/* 删除首节点后的所有节点*/
}
void order(struct freeList **empty,int bySize,int inc)
{
struct freeList *p,*q,*temp;
int startAddress,size;
for(p = (*empty) -> next;p;p = p -> next)
{ /* 按bySize和inc两个参数寻找合适的节点,用temp指向它*/ for(temp = q = p;q;q = q -> next)
{
switch(bySize)
case 0 : switch(inc)
{
case 0:if(q->size < temp->size)
temp = q;break;
default:if(q->size > temp->size)
temp = q;break;
} break;
default: switch(inc)
{
case 0:if(q->startAddress < temp->startAddress)
temp = q;break;
default:if(q->startAddress > temp->startAddress)
temp = q;break;
} break;
}
} /* 交换节点的成员值*/
if(temp != p)
{
startAddress = p->startAddress;
size = p->size;
p->startAddress = temp->startAddress;
p->size = temp->size;
temp->startAddress = startAddress;
temp->size = size;
}
}
}
int allocate(struct freeList **empty,int size)
/*为作业分配存储空间、状态必须为0*/
{
struct freeList *p,*prep;
int startAddress = -1;
p = (*empty) -> next;
while(p && p->size < size)
p = p -> next;
if(p != NULL)
{
if(p -> size > size)
{
startAddress = p -> startAddress;
p -> startAddress += size;
p -> size -= size;
}
else
{
startAddress = p -> startAddress;
prep = *empty;
while(prep -> next != p)
prep = prep -> next;
prep -> next = p -> next;
free(p);
}
}
else printf("\nMay be you should move the fragment together ."); /* Unsuccessful ! */
return startAddress;
}
void insertUsedNode(struct usedList **used,int id,int startAddress) /*插入释放的空间到used链表中(作业号为id,startAddress由函数13返回)*/
{
struct usedList *q,*r,*prer;
if((q = malloc(sizeof(struct usedList))) == NULL)
{
printf("\nNot enough to allocate for the used node .");
errorMessage();
}
q -> startAddress = startAddress;
q -> jobID = id;
prer = *used;
r = (*used) -> next;
while(r && r->startAddress < startAddress)
{
prer = r;
r = r -> next;
}
q -> next = prer -> next;
prer -> next = q;
}
int finishJob(struct usedList **used,int id,int *startAddress)
/*结束一个作业号为id的作业,释放存储空间(由*startAddress返回空间的起始地址)*/
{
struct usedList *p,*prep;
prep = *used;
p = prep -> next;
while(p && p -> jobID != id)
{
prep = p;
p = p -> next;
}
if(p == NULL)
{
printf("\nThe job which id is : %d is not in the memory !",id);
return 0;
}
else
{
*startAddress = p->startAddress;
prep -> next = p -> next;
free(p);
return 1;
}
}
void insertFreeNode(struct freeList **empty,int startAddress,int size)
/*插入回收的空节点分区,处理回收分区与空闲分区的四种邻接关系。*/ {
struct freeList *p,*q,*r;
for(p = *empty;p -> next;p = p -> next) ;
/* 处理链表尾部的邻接情况*/
if(p == *empty || p -> startAddress + p -> size < startAddress)
/* 与尾部不相邻*/
{
makeFreeNode(&r,startAddress,size);
/* 通过r指针返回创建的空闲节点*/
r -> next = p -> next; /* 插入独立的空闲节点*/
p -> next = r;
return ;
}
if(p -> startAddress + p -> size == startAddress) /* 与尾部上邻*/
{
p -> size += size; /* 合并尾部节点*/
return ;
}
q = (*empty) -> next; /* 处理链表首节点的邻接情况*/ if(startAddress + size == q -> startAddress) /* 与首节点下邻*/
{
q -> startAddress = startAddress; /* 合并首节点*/
q -> size += size;
}
else if(startAddress + size < q -> startAddress)
/* 与首节点不相邻*/
{
makeFreeNode(&r,startAddress,size);
r -> next = (*empty) -> next;
(*empty) -> next = r;
}
else
{ /* 处理链表中间的邻接情况*/ while(q -> next && q->startAddress < startAddress)
{
p = q;
q = q -> next;
}
if(p->startAddress+p->size == startAddress &&\
q->startAddress == startAddress+size) /* 上下邻,合并节点*/ {
p->size+= size+q->size;
p->next =q->next;
free(q); /* 删除多余节点*/ }
else if(p -> startAddress + p -> size == startAddress &&\
q -> startAddress != startAddress + size)
/*上邻,增加节点的大小*/
{
p -> size += size;
}
else if(p -> startAddress + p -> size != startAddress &&\
q -> startAddress == startAddress + size) /* 下邻*/ {
q -> startAddress = startAddress; /* 修改节点起始地址*/
q -> size += size; /* 修改节点的大小*/ }
else
{ /* 上下不相邻*/ makeFreeNode(&r,startAddress,size);
r -> next = p -> next;
p -> next = r;
}
}
}
void main(void)
{
char fitMethod;
FILE *fp;
struct jobList *jobs;
struct freeList *empty;
struct usedList *used;
if((used = malloc(sizeof(struct usedList))) == NULL)
{
printf("\nNot enough to allocate for the used node.");
errorMessage();
}
used -> next = NULL;
remove("d:\\result.cl");
makeFreeNode(&empty,0,0);
while(1)
{
char ch,step;
int id,size,startAddress,status;
struct jobList *q;
printf("\n1-----------Initializiation.\
\n2-----------Put job into memory(allocate memory).\
\n3-----------Finish job(reuse memory).\
\n4-----------Show current free list.\
\n5-----------Show current memory used by jobs.\
\n6-----------Move fragment together.\
\n7-----------Exit.");
printf("\nPlease select a digit to continue.\n");
step = getche();
printf("\n");
switch(step)
{
case '1':
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tInitializiation :)");
used -> next = NULL;
empty->next = NULL;
iniMemory();
makeFreeNode(&(empty->next),memoryStartAddress,memorySize);
fprintf(fp,"\n\n\nDo you want to use your job file directly ?\
\nDefault is \'N\' . Y/N : ");
printf("\n\n\nDo you want to use your job file directly ?\
\nDefault is \'N\' . Y/N : \n");
ch = getche();
fprintf(fp,"\n%c",ch);
fclose(fp);
if(ch != 'Y'&& ch != 'y')
{
inputJob();
}
makeJobList(&jobs);
if(ch == 'Y'|| ch == 'y')
{
for(q = jobs->next;q;q = q->next)
{
if(q->status == 1)
{
startAddress = allocate(&empty,q->size);
if(startAddress != -1)
{
insertUsedNode(&used,q->id,startAddress);
}
}
}
}
fitMethod = selectFitMethod();
break;
case '2':
if(memoryStartAddress < 0 || memorySize < 1)
{
printf("\n\nBad memory allocated !\a");
break;
}
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tPut job into memory(allocate memory) ...");
fprintf(fp,"\n\n\nDo you want to allocate for job from keyboard ?\ \nDefault is \'N\' . Y/N : ");
printf("\n\n\nDo you want to allocate for job from keyboard ?\ \nDefault is \'N\' . Y/N : \n");
ch = getche();
fprintf(fp,"\n%c",ch);
fclose(fp);
if(ch != 'Y' && ch != 'y')
{
for(q = jobs->next;q;q = q->next) {
if(q->status == 0)
{
switch(fitMethod)
{
case '1': order(&empty,0,0);break;
case '2': order(&empty,0,1);break;
case '3': order(&empty,1,0);break;
case '4': order(&empty,1,1);break;
}
startAddress = allocate(&empty,q->size);
if(startAddress != -1)
{
insertUsedNode(&used,q->id,startAddress);
updateJobStatus(&jobs,q->id,1);
}
}
}
updateJobFile(jobs);
}
else
{
showJobList(jobs);
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\nPlease input a job id from above .");
printf("\nPlease input a job id from above .");
scanf("%d",&id);
fprintf(fp,"%d\n",id);
getJobInfo(jobs,id,&size,&status);
switch(status)
{
case 0: printf("\nOk !The job's status is correct !");
fprintf(fp,"\nOk !The job's status is correct !");fclose(fp);break;
case 1: printf("\nThe job was in the memory !");
fprintf(fp,"\nThe job was in the memory !");fclose(fp);goto label;
case 2: printf("\nThe job was finished !");
fprintf(fp,"\nThe job was finished !");fclose(fp);goto label;
default:printf("\nUnexpected job status .Please check you job file.");
fprintf(fp,"\nUnexpected job status .Please check you job file.");
fclose(fp);errorMessage();
}
switch(fitMethod)
{
case '1': order(&empty,0,0);break;
case '2': order(&empty,0,1);break;
case '3': order(&empty,1,0);break;
case '4': order(&empty,1,1);break;
}
startAddress = allocate(&empty,size);
if(startAddress != -1)
{
insertUsedNode(&used,id,startAddress);
updateJobStatus(&jobs,id,1);
updateJobFile(jobs);
}
}
label : ;
break;
case '3':
if(memoryStartAddress < 0 || memorySize < 1)
{
printf("\n\nBad memory allocated !\a");
break;
}
do{
int i;
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tFinish job(reuse memory). ...");
fclose(fp);
if(showUsedList(jobs,used) == 0)
break;
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\nPlease input the id from above .\nInput -1 to end the finish job task .");
printf("\nPlease input the id from above .\nInput -1 to end the finish job task .");
scanf("%d",&id);
fprintf(fp,"%d\n",id);
fclose(fp);
if(id == -1)
break;
getJobInfo(jobs,id,&size,&status);
if(status == 1)
{
i = finishJob(&used,id,&startAddress);
if(i)
{
insertFreeNode(&empty,startAddress,size);
updateJobStatus(&jobs,id,2);
updateJobFile(jobs);
}
}
else
{
if(status == 0 || status == 2)
{
if(status == 0)
printf("\nThe job was not in the memory !");
else printf("\nThe job was finished !");
}
else
{
printf("\nUnexpected job status .\
Please check you job file.");
errorMessage();
}
}
}while(1);
break;
case '4':
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tShow current free list. ...");
fclose(fp);
showFreeList(empty);
break;
case '5':
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tShow current memory used by jobs. ...");
fclose(fp);
showUsedList(jobs,used);
break;
case '6':
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tMove fragment together. ...");
fclose(fp);
moveFragment(jobs,&empty,&used);
break;
case '7':
openFile(&fp,"d:\\result.cl","a");
fprintf(fp,"\n\n\tExit :(");
fclose(fp);
exit(0);
default: printf("\nWrong choice !");
}
}
getch();
}
linux源代码分析:Linux操作系统源代码详细分析 疯狂代码 https://www.doczj.com/doc/ea5725818.html,/ ?:http:/https://www.doczj.com/doc/ea5725818.html,/Linux/Article28378.html 内容介绍: Linux 拥有现代操作系统所有功能如真正抢先式多任务处理、支持多用户内存保护虚拟内存支持SMP、UP符合POSIX标准联网、图形用户接口和桌面环境具有快速性、稳定性等特点本书通过分析Linux内核源代码充分揭示了Linux作为操作系统内核是如何完成保证系统正常运行、协调多个并发进程、管理内存等工作现实中能让人自由获取系统源代码并不多通过本书学习将大大有助于读者编写自己新 第部分 Linux 内核源代码 arch/i386/kernel/entry.S 2 arch/i386/kernel/init_task.c 8 arch/i386/kernel/irq.c 8 arch/i386/kernel/irq.h 19 arch/i386/kernel/process.c 22 arch/i386/kernel/signal.c 30 arch/i386/kernel/smp.c 38 arch/i386/kernel/time.c 58 arch/i386/kernel/traps.c 65 arch/i386/lib/delay.c 73 arch/i386/mm/fault.c 74 arch/i386/mm/init.c 76 fs/binfmt-elf.c 82 fs/binfmt_java.c 96 fs/exec.c 98 /asm-generic/smplock.h 107 /asm-i386/atomic.h 108 /asm- i386/current.h 109 /asm-i386/dma.h 109 /asm-i386/elf.h 113 /asm-i386/hardirq.h 114 /asm- i386/page.h 114 /asm-i386/pgtable.h 115 /asm-i386/ptrace.h 122 /asm-i386/semaphore.h 123 /asm-i386/shmparam.h 124 /asm-i386/sigcontext.h 125 /asm-i386/siginfo.h 125 /asm-i386/signal.h 127 /asm-i386/smp.h 130 /asm-i386/softirq.h 132 /asm-i386/spinlock.h 133 /asm-i386/system.h 137 /asm-i386/uaccess.h 139 //binfmts.h 146 //capability.h 147 /linux/elf.h 150 /linux/elfcore.h 156 /linux/errupt.h 157 /linux/kernel.h 158 /linux/kernel_stat.h 159 /linux/limits.h 160 /linux/mm.h 160 /linux/module.h 164 /linux/msg.h 168 /linux/personality.h 169 /linux/reboot.h 169 /linux/resource.h 170 /linux/sched.h 171 /linux/sem.h 179 /linux/shm.h 180 /linux/signal.h 181 /linux/slab.h 184 /linux/smp.h 184 /linux/smp_lock.h 185 /linux/swap.h 185 /linux/swapctl.h 187 /linux/sysctl.h 188 /linux/tasks.h 194 /linux/time.h 194 /linux/timer.h 195 /linux/times.h 196 /linux/tqueue.h 196 /linux/wait.h 198 init/.c 198 init/version.c 212 ipc/msg.c 213 ipc/sem.c 218 ipc/shm.c 227 ipc/util.c 236 kernel/capability.c 237 kernel/dma.c 240 kernel/exec_do.c 241 kernel/exit.c 242 kernel/fork.c 248 kernel/info.c 255 kernel/itimer.c 255 kernel/kmod.c 257 kernel/module.c 259 kernel/panic.c 270 kernel/prk.c 271 kernel/sched.c 275 kernel/signal.c 295 kernel/softirq.c 307 kernel/sys.c 307 kernel/sysctl.c 318 kernel/time.c 330 mm/memory.c 335 mm/mlock.c 345 mm/mmap.c 348 mm/mprotect.c 358 mm/mremap.c 361 mm/page_alloc.c 363 mm/page_io.c 368 mm/slab.c 372 mm/swap.c 394 mm/swap_state.c 395 mm/swapfile.c 398 mm/vmalloc.c 406 mm/vmscan.c 409
实验一、进程控制实验 1.1 实验目的 加深对于进程并发执行概念的理解。实践并发进程的创建和控制方法。观察和体验进程的动态特性。进一步理解进程生命期期间创建、变换、撤销状态变换的过程。掌握进程控制的方法,了解父子进程间的控制和协作关系。练习Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。 1.2 实验说明 1)与进程创建、执行有关的系统调用说明进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过exec()系统调用族装入一个新的执行程序。父进程可以使用wait()或waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。 fork()系统调用语法: #include
Exec 执行成功后将用一个新的程序代替原进程,但进程号不变,它绝不会再返回到调用进程了。如果exec 调用失败,它会返回-1。 wait() 系统调用语法: #include
Android是一种基于Linux的自由及开放源代码的操作系统,主要使用于移动设备,如智能手机和平板电脑,由Google公司和开放手机联盟领导及开发。尚未有统一中文名称,中国大陆地区较多人使用“安卓”或“安致”。Android操作系统最初由Andy Rubin开发,主要支持手机。2005年8月由Google收购注资。2007年11月,Google与84家硬件制造商、软件开发商及电信营运商组建开放手机联盟共同研发改良Android系统。随后Google以Apache开源许可证的授权方式,发布了Android的源代码。第一部Android智能手机发布于2008年10月。Android逐渐扩展到平板电脑及其他领域上,如电视、数码相机、游戏机等。2011年第一季度,Android在全球的市场份额首次超过塞班系统,跃居全球第一。2012年11月数据显示,Android占据全球智能手机操作系统市场76%的份额,中国市场占有率为90%。 中文名:安卓 外文名:Android 开发商:Google、开放手持设备联盟 发行商:Google 发行时间:2008年9月23日 编程语 言: C/C++(底层)Java等(应用 层) 系统家 族: 类Unix,Linux 源码模 式: 自由及开放源代码软件 内核类 型: 宏内核(Linux内核) 软件许 可: Apache License, GPL等 Android一词的本义指“机器人”,同时也是Google于2007年11月5日宣布的基于Linux 平台的开源手机操作系统的名称,该平台由操作系统、中间件、用户界面和应用软件组成。 Android一词最早出现于法国作家利尔亚当(Auguste Villiers de l'Isle-Adam)在1886年发 表的科幻小说《未来夏娃》(L'ève future)中。他将外表像人的机器起名为Android。 Android的Logo是由Ascender公司设计的。其中的文字使用了Ascender公司专门制作的 称之为“Droid ” 的字体。Android是一个全身绿色的机器人,绿色也是Android的标志。颜 色采用了PMS 376C和RGB中十六进制的#A4C639来绘制,这是Android操作系统的品牌 象徵。有时候,它们还会使用纯文字的Logo。 2012年7月美国科技博客网站BusinessInsider评选出二十一世纪十款最重要电子产品,Android操作系统和iPhone等榜上有名。
①实验题目; 进程调度算法设计与实现 ②程序中所用数据结构及说明; 界面设计:使用switch语句,采用调用二维数组中的数据; 进程排序:采用冒泡排序法,将优先级高的进程调换; While循环重复执行进程调度,优先级高的进程调换,每运行一个时间片优先数减3,进程占用时间加1,进程尚需时间减1。 ③程序清单及描述; #include
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同,PCB结构的内容可以作适当的增删)。为了便于处理,程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类,每类数目为r1…r w。随机产生n进程P i(id,s(j,k),t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间,在运行过程中,会随机申请新的资源。 3、每个进程可有三个状态(即就绪状态W、运行状态R、等待或阻塞状态B),并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法:时间片轮转调度算法 本程序用该算法对n个进程进行调度,进程每执行一次,CPU时间片数加1,进程还需要的时间片数减1。在调度算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了1个单位),这时,CPU时间片数加1,进程还需要的时间片数减1,并排列到就绪队列的尾上。 三、实验环境 操作系统环境:Windows系统。 编程语言:C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态,W(等待)、R(运行)、B(阻塞) //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数,n为初始化进程个数 //r为可随机产生的进程数(r=m-n) //a,b,c分别为A,B,C三类资源的总量 //i为进城计数,i=1…n //h为运行的时间片次数,time1Inteval为时间片大小(毫秒) //对进程进行初始化,建立就绪数组、阻塞数组。 public void input()//对进程进行初始化,建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
6. 算法题(共32个题目) 200348. 在信号量机制中,若P(S)操作是可中断的,则会有什么问题? 此题答案为:答: P(S)的操作如下: Begin S.Value:= S.Value-1; ① If S.Value<0 Then ② Begin Insert(*,S.L); Block(*) ③ End End. 若P(S)可中断的,例如进程A在执行了语句①之后从CPU上退 下了,假定此时S.Value=0;这时换另一进程B,B又将S.Value 的值减1使之为-1,在执行语句③时,B被阻塞;然后又换回A执行,由于A的"断点"是语句①之后,当它执行语句②时,由于这时S.Value已经是-1,故进程继续执行而被阻塞。这就出现了错误: 本来A操作P(S)操作后,S.Value=0,是不应该被阻塞的,现在却被阻塞了。 200350. 何谓临界区?下面给出的两个进程互斥的算法是安全的吗?为什么?
#define true; # define false; Int flag[2]; flag[1]=flag[2]=false; enter-crtsec(i) int i; { While(flag[1-i]) flag[i]=true; } feave-crtsec(i) Int i; { flag[i]=false; } process I; … Enter-crtsec(i); In critical section; Leave-crtsec(i);
此题答案为:答:一次仅允许一个进程使用的资源称为临界资源,在进程中对临界资源访问的程序段称为临界区。 从概念上讲,系统中各进程在逻辑上是独立的,它们可以按各自的速度向前推进。但由于它们共享某些临界资源,因而产生了临界区问题。对于具有临界区问题的并发进程,它们之间必须互斥,以保证不会同时进入临界区。 这种算法不是安全的。因为,在进入临界区的enter-crtsec()不是一个原语操作,如果两个进程同时执行完其循环(此前两个flag均为false),则这两个进程可同时进入临界区。 200353. 某车站售票厅,任何时刻最多可容纳20名购票者进入,当售票少于20名购票者时,则厅外的购票者可立即进入,否则需在外面等待。若把一个购票者看作一个进程,请回答下列问题: (1)用P、V操作管理这些并发进程时,应怎样定义信号量?写出信号量的初值以及信号量各种取值的含义。 (2)根据所定义的信号量,把应执行的P、V操作填入下述程序中,以保证进程能够正确地并发执行。 Cobegin PROCESS Pi(i=1,2,…) Begin 进入售票厅; 购票; 退出; End;
Linux操作系统源代码详细分析 容简介: Linux 拥有现代操作系统所有的功能,如真正的抢先式多任务处理、支持多用户,存保护,虚拟存,支持SMP、UP,符合POSIX标准,联网、图形用户接口和桌面环境。具有快速性、稳定性等特点。本书通过分析Linux的核源代码,充分揭示了Linux作为操作系统的核是如何完成保证系统正常运行、协调多个并发进程、管理存等工作的。现实中,能让人自由获取的系统源代码并不多,通过本书的学习,将大大有助于读者编写自己的新程序。 第一部分 Linux 核源代码 arch/i386/kernel/entry.S 2 arch/i386/kernel/init_task.c 8 arch/i386/kernel/irq.c 8 arch/i386/kernel/irq.h 19 arch/i386/kernel/process.c 22 arch/i386/kernel/signal.c 30 arch/i386/kernel/smp.c 38 arch/i386/kernel/time.c 58 arch/i386/kernel/traps.c 65 arch/i386/lib/delay.c 73 arch/i386/mm/fault.c 74 arch/i386/mm/init.c 76 fs/binfmt-elf.c 82 fs/binfmt_java.c 96 fs/exec.c 98 include/asm-generic/smplock.h 107 include/asm-i386/atomic.h 108 include/asm-i386/current.h 109 include/asm-i386/dma.h 109 include/asm-i386/elf.h 113 include/asm-i386/hardirq.h 114 include/asm-i386/page.h 114 include/asm-i386/pgtable.h 115 include/asm-i386/ptrace.h 122 include/asm-i386/semaphore.h 123 include/asm-i386/shmparam.h 124 include/asm-i386/sigcontext.h 125 include/asm-i386/siginfo.h 125 include/asm-i386/signal.h 127 include/asm-i386/smp.h 130 include/asm-i386/softirq.h 132 include/asm-i386/spinlock.h 133 include/asm-i386/system.h 137 include/asm-i386/uaccess.h 139
第二章操作系统进程(练习题答案)
————————————————————————————————作者:————————————————————————————————日期: 2
第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理,以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有:处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件,后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下,计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案: (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案:CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件,是 (2) 的接口。 在处理机管理中,进程是一个重要的概念,它由程序块、 (3) 和数据块三部 分组成,它有3种基本状态,不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间,它通常使用 (5) 作为它的一个主要组成部分。 供选答案: (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案:CDADB 3.在计算机系统中,允许多个程序同时进入内存并运行,这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。
现在手机的操作系统主要有Android (安卓)Symbian(塞班)和windows这三种,其中以安卓最火。 我说的很详细,你看看下面的文字差不多都会明白。。。 小米手机MIUI系统:(图片) 小米手机采用Android OS v2.3+MIUI双系统,双系统之间自选(MIUI系统之间数据可以同步,原生系统与MIUI系统数据不能同步)功能上苹果的IOS比Android OS还是要好一点的,特别在优化流畅性和用户体验上面。而Android开源是最大的优势,自由度大,但是优化不足,配置低的手机用起来有点卡
联想乐Phone的系统版本是采用基于Android操作系统的乐Phone OS 平台。Android操作系统是谷歌开发的操作系统,OS即Operation System,号称第一款开源手机系统 联想手机系统:乐OS系统 独有的手写输入法基本功能方面,联想乐OS采用了独有的手写输入法,可以快速输入中英文、数字和标点符号等内容,特别适合国人使用。另外,乐OS支持自动推送功能,新闻、邮件、股票、音乐和视频等热点资讯都会在第一时间推送到手机之上,不会让你错过任何重要的信息。 Lephone 3Gw101(图片)
我的手机图片: 刷机后图片系统(小米MIUI)系统Android 2.3.9 时间过得很快,剩下一年就毕业了,平时有空闲时间多关注人为地理历史方面的知识,这样有助于提升你的阅历,跨专业跨行业了解一些东西,比如地理方面,虽然这个地方你没有去过,但是你通过网络或书籍知道这个地方的人为地理历史背景等。别人问你的时候,你也能回答上来,读万卷书不如行万里路,行万里路不如阅人无数。就是这个道理。尤其是我学工科的,更应该弥补人为方面的不足。
上海电力学院 计算机操作系统原理 课程设计报告 题目名称:编写程序模拟虚拟存储器管理 姓名:杜志豪.学号: 班级: 2012053班 . 同组姓名:孙嘉轶 课程设计时间:—— 评语: 成绩: 目录 一、设计内容及要求 (4) 1. 1 设计题目 (4) 1.2 使用算法分析: (4)
1. FIFO算法(先进先出淘汰算法) (4) 1. LRU算法(最久未使用淘汰算法) (5) 1. OPT算法(最佳淘汰算法) (5) 分工情况 (5) 二、详细设计 (6) 原理概述 (6) 主要数据结构(主要代码) (6) 算法流程图 (9) 主流程图 (9) Optimal算法流程图 (10) FIFO算法流程图 (10) LRU算法流程图 (11) .1源程序文件名 (11) . 2执行文件名 (11) 三、实验结果与分析 (11) Optimal页面置换算法结果与分析 (11) FIFO页面置换算法结果与分析 (16) LRU页面置换算法结果与分析 (20) 四、设计创新点 (24) 五、设计与总结 (27)
六、代码附录 (27) 课程设计题目 一、设计内容及要求 编写程序模拟虚拟存储器管理。假设以M页的进程分配了N
块内存(N ##include 第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理,以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有:处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件,后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下,计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案: (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案:CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件,是 (2) 的接口。 在处理机管理中,进程是一个重要的概念,它由程序块、 (3) 和数据块三部 分组成,它有3种基本状态,不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间,它通常使用 (5) 作为它的一个主要组成部分。 供选答案: (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案:CDADB 3.在计算机系统中,允许多个程序同时进入内存并运行,这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。 android Android一词的本义指“机器人”,同时也是Google于2007年11月5日宣布的基于Linu x平台的开源手机操作系统的名称,该平台由操作系统、中间件、用户界面和应用软件组成,号称是首个为移动终端打造的真正开放和完整的移动软件。目前最好的是Android2.0的摩托罗拉Droid 目录[显示] [编辑本段] 简介 Android是基于Linux内核的软件平台和操作系统,早期由Google开发,后由开放手机联盟(Open Handset Alliance)开发。它采用了软件堆层(software st ack,又名为软件叠层)的架构,主要分为三部分。底层以Linux内核工作为基础,只提供基本功能;其他的应用软件则由各公司自行开发,以Java作为编写程序的一部分。另外,为了推广此技术,Google和其它几十个手机公司建立了开放手机联盟。Android在未公开之前常被传闻为Google电话或gPhone。大多传闻认为Goog le开发的是自己的手机电话产品,而不是一套软件平台。到了2010年1月,Googl e开始发表自家品牌手机电话的NexusOne。目前最新版本为Android2.1。 对手机行业的影响 已经与HTC、NTT DoCoMo、KDDI、Motorola等世界移动领域34家公司于免费提供达成一致。今后对于移动通讯的影响势必会进一步体现出来。但是如此广泛公司的同盟是否能够有效运作以及持久,让我们拭目以待。 Android手机 2008年9月22日,美国运营商T-MobileUSA在纽约正式发布第一款Goog le手机——T-Mobile G1。该款手机为台湾宏达电代工制造,是世界上第一部使用Android操作系统的手机,支持WCDMA/HSPA网络,理论下载速率7.2Mbps,并支持Wi-Fi。 (左图为Androidlogo) [编辑本段] 课程设计报告 题 目 操作系统算法设计 课 程 名 称 操作系统课程设计 院 部 名 称 计算机工程学院 专 业 计算机科学与技术 班 级 14计算机科学与技术单 学 生 姓 名 邵佳楠 学 号 141320100 课程设计地点 A107 课程设计学时 20学时 指 导 教 师 潘 金陵科技学院教务处制 成绩 目录 摘要 (2) 一、课程设计的目的和要求 (3) 二、系统需求分析 (3) 三、总体设计 (3) 四、详细设计 (4) 五、测试、调试过程 (7) 六、结论与体会 (16) 附录:源程序 (17) 摘要 (32) 一、课程设计的目的和要求 (33) 二、系统需求分析 (33) 三、总体设计 (33) 四、详细设计 (33) 五、测试、调试过程 (34) 六、结论与体会 (38) 附录:源程序 (39) 摘要 (47) 一、设计的目的和要求 (47) 二、系统需求分析 (48) 三、总体设计 (48) 四、详细设计 (48) 五、测试、调试过程 (50) 六、结论与体会 (54) 附录:源程序 (55) 操作系统算法设计-进程调度程序 摘要 随着计算机的普及,人们生活得到极大改善,人们在精神方面也同样需要提高,所以越来越多的人进行着各种各样的学习。操作系统是计算机中最重要的环节之一,也是计算机专业学生的一门重要的专业课程。操作系统的好坏,直接影响整个计算机系统的性能和用户对计算机的使用。一个精心设计的操作系统能极大的扩展计算机的功能,充分发挥系统中的各种设备的使用效率,提高系统的可靠性。由于操作系统中各种软硬件资源的管理,内容比较繁琐,具有很强的实践性,要学好这门课程,必须把理论和时间紧密结合,才能取得较好的学习效果。 本次课程设计师在学习完《操作系统教程》后,进行的一次全面的综合训练,通过课程设计,让学生更好的掌握操作系统的原理以及实现方法,加深对操作系统基础理论和重要算法的理解,加强对学生的动手能力。 熟悉“最高优先级优先调度算法”、“基于时间片轮转法”、“多级反馈队列调度算法”、“最高优先级优先算法”,虽然不用全部每一个都弄清楚,但是了解其中的算法思想也是有好处的。 关键词:最高优先级优先调度算法、基于时间片轮转法、多级反馈队列调度算法、最高优先级优先算法 第1部分操作系统概论名词解释 脱机输入/输出 具体的输入/输出不需要在主计算机上进行的方式也称“脱机输入/输出” 批处理 作业是由操作系统成批地进行处理,操作系统能自动地从输入池读入下一个作业,并予以运行和输出,如此直到整批作业全部处理完毕。 SPOOLING 由操作系统将磁盘模拟为输入/输出设备的处理方式称为SPOOLING(Simultaneous Periph eral Operating On Line),即“并行的外部设备操作联机”,也称“假脱机”。SPOOLING系统是以磁盘为几乎无限巨大的缓冲区来解决低速的I/O设备与高速的CPU之间的速度匹配问题。 分时系统 为了降低交互式系统的等待时间和运行时间的比率,系统通过多台终端同时向很多用户提供运行环境,这种分时系统就能以合理的成本向用户提供交互式使用计算机的方便。 多路性 一台主机可连接多台终端,多个终端用户可以同时使用计算机,共享系统的硬软件资源。 交互性 用户能与系统进行对话。在一个多步骤作业的运行过程中,用户能通过键盘等设备输入数据或命令,系统获得用户的输入后做出响应,显示执行的状况或结果。 实时操作系统 是一种能在限定的时间内对输入进行快速处理并做出响应的计算机处理系统 多处理机系统 一个计算机系统中可具有多个CPU或处理机。一般用微处理器构成阵列系统,其运算速度可以达到上万亿次, 分布式操作系统 分布式系统是一种多计算机系统,这些计算机可以处于不同的地理位置和拥有不同的软硬件资源,并用通信线路连接起来,具有独立执行任务的能力。分布式系统具有一个统一的操作系统,它可以把一个大任务划分成很多可以并行执行的子任务,并按一定的调度策略将它们动态地分配给各个计算机执行,并控制管理各个计算机的资源分配、运行及计算机之间的通信,以协调任务的并行执行。以上所有的管理工作对用户都是透明的。 网络操作系统 计算机网络是指用数据通信系统把分散在不同地方的计算机群和各种计算机设备连接起来的集合,它主要用于数据通信和资源共享,特别是软件和信息共享。 安卓操作系统简介 简言: Android一词的本义指“机器人”,同时也是Google于2007年11月5日宣布的基于Linux平台的开源手机操作系统的名称,该平台由操作系统、中间件、用户界面和应用软件组成,号称是首个为移动终端打造的真正开放和完整的移动软件。目前,最新版本为Android 2.4 Gingerbread和Android 3.0 Honeycomb。 系统介绍: Android是基于Linux内核的操作系统,是Google公司在2007年11月5日公布的手机操作系统,早期由Google开发,后由开放手持设备联盟(Open Handset Alliance)开发。它采用了软件堆层(software stack,又名以软件叠层)的架构,主要分为三部分。底层Linux内核只提供基本功能;其他的应用软件则由各公司自行开发,部分程序以Java编写。 2010年末数据显示,仅正式推出两年的操作系统Android已经超越称霸十年的诺基亚(Nokia)Symbian OS系统,采用Android系统主要手机厂商包括宏达电子(HTC)、三星(SAMSUNG)、摩托罗拉(MOTOROLA)、LG、Sony Ericsson、魅族M9等,使之跃居全球最受欢迎的智能手机平台,Android系统不但应用于智能手机,也在平板电脑市场急速扩张。 系统架构: 应用程序: Android以Java为编程语言,使接口到功能,都有层出不穷的变化,其中Activity 等同于J2ME的MIDlet,一个Activity 类(class)负责创建视窗(window),一个活动中的Activity就是在foreground(前景)模式,背景运行的程序叫做Service。两者之间通过由ServiceConnection和AIDL连结,达到复数程序同时运行的效果。如果运行中的Activity 全部画面被其他Activity 取代时,该Activity 便被停止(stopped),甚至被系统清除(kill)。 View等同于J2ME的Displayable,程序人员可以通过View 类与“XML layout”档将UI放置在视窗上,Android 1.5的版本可以利用View 打造出所谓的Widgets,其实Widget只是View的一种,所以可以使用xml来设计layout,HTC 的Android Hero手机即含有大量的widget。至于ViewGroup 是各种layout 的基础抽象类(abstract class),ViewGroup之内还可以有ViewGroup。View的构造函数不需要再Activity中调用,但是Displayable的是必须的,在Activity 中,要通过findViewById()来从XML中取得View,Android的View类的显示很大程度上是从XML中读取的。View 与事件(event)息息相关,两者之间通过Listener 结合在一起,每一个View都可以注册一个event listener,例如:当View要处理用户触碰(touch)的事件时,就要向Android框架注册View.OnClickListener。另外还有Image等同于J2ME的BitMap。 中介软件 操作系统与应用程序的沟通桥梁,并用分为两层:函数层(Library)和虚拟机(Virtual Machine)。Bionic是Android 改良libc的版本。Android 同时包含了Webkit,所谓的Webkit 就是Apple Safari 浏览器背后的引擎。Surface flinger 是就2D或3D的内容显示到屏幕上。Android使用工具链(Toolchain)为Google自操作系统课程设计银行系统源代码
第二章-操作系统进程(练习题答案)
android系统详细介绍
操作系统算法设计操作系统课程设计大学论文
计算机操作系统概论名词解释
安卓操作系统简介