多线程程序设计实验报告心得(多线程编程实验总结)

一个Linux多进程编程？

1 引言

对于没有接触过Unix/Linux操作系统的人来说，fork是最难理解的概念之一：它执行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不同，Unix/Linux系统是真正实现多任务操作的系统，可以说，不使用多进程编程，就不能算是真正的Linux环境下编程。

多线程程序设计的概念早在六十年代就被提出，但直到八十年代中期，Unix系统中才引入多线程机制，如今，由于自身的许多优点，多线程编程已经得到了广泛的应用。

下面，我们将介绍在Linux下编写多进程和多线程程序的一些初步知识。

2 多进程编程

什么是一个进程？进程这个概念是针对系统而不是针对用户的，对用户来说，他面对的概念是程序。当用户敲入命令执行一个程序的时候，对系统而言，它将启动一个进程。但和程序不同的是，在这个进程中，系统可能需要再启动一个或多个进程来完成独立的多个任务。多进程编程的主要内容包括进程控制和进程间通信，在了解这些之前，我们先要简单知道进程的结构。

2.1 Linux下进程的结构

Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。其实学过汇编语言的人一定知道，一般的CPU都有上述三种段寄存器，以方便操作系统的运行。这三个部分也是构成一个完整的执行序列的必要的部分。

"代码段"，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。这其中有许多细节问题，这里限于篇幅就不多介绍了。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。

2.2 Linux下的进程控制

在传统的Unix环境下，有两个基本的操作用于创建和修改进程：函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec( )用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统中调用vfork和fork完全相同，而在有些版本的Unix系统中，vfork调用有不同的功能。由于这些差别几乎不影响我们大多数的编程，在这里我们不予考虑。

2.2.1 fork( )

fork在英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就"分叉"了，所以这个名字取得很形象。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架：

void main(){

int i;

if ( fork() == 0 ) {

/* 子进程程序 */

for ( i = 1; i 1000; i ++ ) printf("This is child process\n");

}

else {

/* 父进程程序*/

for ( i = 1; i 1000; i ++ ) printf("This is process process\n");

}

}

程序运行后，你就能看到屏幕上交替出现子进程与父进程各打印出的一千条信息了。如果程序还在运行中，你用ps命令就能看到系统中有两个它在运行了。

那么调用这个fork函数时发生了什么呢？fork函数启动一个新的进程，前面我们说过，这个进程几乎是当前进程的一个拷贝：子进程和父进程使用相同的代码段；子进程复制父进程的堆栈段和数据段。这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。它们再要交互信息时，只有通过进程间通信来实现，这将是我们下面的内容。既然它们如此相象，系统如何来区分它们呢？这是由函数的返回值来决定的。对于父进程，fork函数返回了子程序的进程号，而对于子程序，fork函数则返回零。在操作系统中，我们用ps函数就可以看到不同的进程号，对父进程而言，它的进程号是由比它更低层的系统调用赋予的，而对于子进程而言，它的进程号即是fork函数对父进程的返回值。在程序设计中，父进程和子进程都要调用函数fork（）下面的代码，而我们就是利用fork（）函数对父子进程的不同返回值用if...else...语句来实现让父子进程完成不同的功能，正如我们上面举的例子一样。我们看到，上面例子执行时两条信息是交互无规则的打印出来的，这是父子进程独立执行的结果，虽然我们的代码似乎和串行的代码没有什么区别。

读者也许会问，如果一个大程序在运行中，它的数据段和堆栈都很大，一次fork就要复制一次，那么fork的系统开销不是很大吗？其实UNIX自有其解决的办法，大家知道，一般CPU都是以"页"为单位来分配内存空间的，每一个页都是实际物理内存的一个映像，象INTEL的CPU，其一页在通常情况下是4086字节大小，而无论是数据段还是堆栈段都是由许多"页"构成的，fork函数复制这两个段，只是"逻辑"上的，并非"物理"上的，也就是说，实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的"页"从物理上也分开。系统在空间上的开销就可以达到最小。

下面演示一个足以"搞死"Linux的小程序，其源代码非常简单：

void main()

{

for( ; ; ) fork();

}

这个程序什么也不做，就是死循环地fork，其结果是程序不断产生进程，而这些进程又不断产生新的进程，很快，系统的进程就满了，系统就被这么多不断产生的进程"撑死了"。当然只要系统管理员预先给每个用户设置可运行的最大进程数，这个恶意的程序就完成不了企图了。

2.2.2 exec( )函数族

下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同，在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp为例，其它函数究竟与execlp有何区别，请通过manexec命令来了解它们的具体情况。

一个进程一旦调用exec类函数，它本身就"死亡"了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。（不过exec类函数中有的还允许继承环境变量之类的信息。）

那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序：

char command[256];

void main()

{

int rtn; /*子进程的返回数值*/

while(1) {

/* 从终端读取要执行的命令 */

printf( "" );

fgets( command, 256, stdin );

command[strlen(command)-1] = 0;

if ( fork() == 0 ) {

/* 子进程执行此命令 */

execlp( command, command );

/* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/

perror( command );

exit( errorno );

}

else {

/* 父进程， 等待子进程结束，并打印子进程的返回值 */

wait ( rtn );

printf( " child process return %d\n",. rtn );

}

}

}

此程序从终端读入命令并执行之，执行完成后，父进程继续等待从终端读入命令。熟悉DOS和WINDOWS系统调用的朋友一定知道DOS/WINDOWS也有exec类函数，其使用方法是类似的，但DOS/WINDOWS还有spawn类函数，因为DOS是单任务的系统，它只能将"父进程"驻留在机器内再执行"子进程"，这就是spawn类的函数。WIN32已经是多任务的系统了，但还保留了spawn类函数，WIN32中实现spawn函数的方法同前述UNIX中的方法差不多，开设子进程后父进程等待子进程结束后才继续运行。UNIX在其一开始就是多任务的系统，所以从核心角度上讲不需要spawn类函数。

在这一节里，我们还要讲讲system（）和popen（）函数。system（）函数先调用fork（），然后再调用exec（）来执行用户的登录shell，通过它来查找可执行文件的命令并分析参数，最后它么使用wait（）函数族之一来等待子进程的结束。函数popen（）和函数system（）相似，不同的是它调用pipe（）函数创建一个管道，通过它来完成程序的标准输入和标准输出。这两个函数是为那些不太勤快的程序员设计的，在效率和安全方面都有相当的缺陷，在可能的情况下，应该尽量避免。

2.3 Linux下的进程间通信

详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐著名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最最简单的一些知识和概念。

首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来，进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。

2.3.1 管道

管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。

无名管道由pipe（）函数创建：

#include unistd.h

int pipe(int filedis[2])；

参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。

#define INPUT 0

#define OUTPUT 1

void main() {

int file_descriptors[2];

/*定义子进程号 */

pid_t pid;

char buf[256];

int returned_count;

/*创建无名管道*/

pipe(file_descriptors);

/*创建子进程*/

if((pid = fork()) == -1) {

printf("Error in fork\n");

exit(1);

}

/*执行子进程*/

if(pid == 0) {

printf("in the spawned (child) process...\n");

/*子进程向父进程写数据，关闭管道的读端*/

close(file_descriptors[INPUT]);

write(file_descriptors[OUTPUT], "test data", strlen("test data"));

exit(0);

} else {

/*执行父进程*/

printf("in the spawning (parent) process...\n");

/*父进程从管道读取子进程写的数据，关闭管道的写端*/

close(file_descriptors[OUTPUT]);

returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));

printf("%d bytes of data received from spawned process: %s\n",

returned_count, buf);

}

}

在Linux系统下，有名管道可由两种方式创建：命令行方式mknod系统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道：

方式一：mkfifo("myfifo","rw");

方式二：mknod myfifo p

生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。

/* 进程一：读有名管道*/

#include stdio.h

#include unistd.h

void main() {

FILE * in_file;

int count = 1;

char buf[80];

in_file = fopen("mypipe", "r");

if (in_file == NULL) {

printf("Error in fdopen.\n");

exit(1);

}

while ((count = fread(buf, 1, 80, in_file)) 0)

printf("received from pipe: %s\n", buf);

fclose(in_file);

}

/* 进程二：写有名管道*/

#include stdio.h

#include unistd.h

void main() {

FILE * out_file;

int count = 1;

char buf[80];

out_file = fopen("mypipe", "w");

if (out_file == NULL) {

printf("Error opening pipe.");

exit(1);

}

sprintf(buf,"this is test data for the named pipe example\n");

fwrite(buf, 1, 80, out_file);

fclose(out_file);

}

2.3.2 消息队列

消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。

2.3.3 共享内存

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。

首先要用的函数是shmget，它获得一个共享存储标识符。

#include sys/types.h

#include sys/ipc.h

#include sys/shm.h

int shmget(key_t key, int size, int flag);

这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。

当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。

void *shmat(int shmid, void *addr, int flag);

shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。

使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

多线程和网络的实训要求

一、实训目的

1.掌握Java多线程编程的两种设计和使用方法;

2.理解多线程的使用，并能通过多线程编程解决实际问题。

二、实训要求

能通过编写简单的多线程程序，掌握Thread和Runnable类的使用,利用多线程编程解决

实际现实问题。

2. 利用多线程设计一个程序，一个线程输出26个小写字母，另一个线程输出26个大写字母

public class RunThread implements Runnable{

String name;

Thread runner;

static boolean bool=true;

public RunThread(String threadName) {

name=threadName;

}

public void onStart()

{

runner = new Thread(this);

runner.setName(name);

runner.start();

}

public void run() {

String name=Thread.currentThread().getName();

System.out.println(name + " 线程运行开始!");

while(true){

int index=0;

if(name.equals("小写字母"))

index='a';

else if(name.equals("大写字母"))

index='A';

while(!bool);

bool=false;

for(int i=index;i26+index;i++)

System.out.print((char)i+" ");

System.out.println();

bool=true;

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

//System.out.println(name + " 线程运行结束!");

}

public static void main(String[] args) {

RunThread a=new RunThread("小写字母");

RunThread b=new RunThread("大写字母");

a.onStart();

b.onStart();

//System.out.println(" 线程运行开始!");

}

}

Java 多线程 资源冲突

来自：开发者在线

Java多线程程序设计详细解析

一、理解多线程

多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。

线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个CPU，那么真正的“同时”是不可能的，但是由于CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它，只需要设想各个线程是同时执行即可。

多线程和传统的单线程在程序设计上最大的区别在于，由于各个线程的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度，同步等问题，将在以后探讨。

二：在Java中实现多线程

我们不妨设想，为了创建一个新的线程，我们需要做些什么？很显然，我们必须指明这个线程所要执行的代码，而这就是在Java中实现多线程我们所需要做的一切！

真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言，Java提供了类java.lang.Thread来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程，我们以后的讨论都将围绕这个类进行。

那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类。Thread 类最重要的方法是run()，它为Thread类的方法start()所调用，提供我们的线程所要执行的代码。为了指定我们自己的代码，只需要覆盖它！

方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：

public class MyThread extends Thread

{

int count= 1, number;

public MyThread(int num)

{

number = num;

System.out.println

("创建线程 " + number);

}

public void run() {

while(true) {

System.out.println

("线程 " + number + ":计数 " + count);

if(++count== 6) return;

}

}

public static void main(String args[])

{

for(int i = 0;

i 〈 5; i++) new MyThread(i+1).start();

}

}

这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？

我们不妨来探索一种新的方法：我们不创建Thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。

那么如何限制这个类必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）

Java 提供了接口 java.lang.Runnable 来支持这种方法。

方法二：实现 Runnable 接口

Runnable接口只有一个方法run()，我们声明自己的类实现Runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是Runnable接口并没有任何对线程的支持，我们还必须创建Thread类的实例，这一点通过Thread类的构造函数public Thread(Runnable target);来实现。下面是一个例子：

public class MyThread implements Runnable

{

int count= 1, number;

public MyThread(int num)

{

number = num;

System.out.println("创建线程 " + number);

}

public void run()

{

while(true)

{

System.out.println

("线程 " + number + ":计数 " + count);

if(++count== 6) return;

}

}

public static void main(String args[])

{

for(int i = 0; i 〈 5;

i++) new Thread(new MyThread(i+1)).start();

}

}

严格地说，创建Thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。

使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。

综上所述，两种方法各有千秋，大家可以灵活运用。

下面让我们一起来研究一下多线程使用中的一些问题。

三、线程的四种状态

1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。

2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

四、线程的优先级

线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

五、线程的同步

由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：

public synchronized void accessVal(int newVal);

synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。

synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。

2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject)

{

//允许访问控制的代码

}

synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

六、线程的阻塞

为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。

1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。

2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。

3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。

4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。

上述的核心区别导致了一系列的细节上的区别。

首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。

而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。

同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。

wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。

它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。关于 wait() 和 notify() 方法最后再说明两点：

第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。

第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。

谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。

以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify()方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。

七、守护线程

守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。

可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。

八、线程组

线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。

你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。

在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。

Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。

Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。

Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。

九、总结

在本文中，我们讲述了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？

多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。

假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的。

来自：开发者在线

我可以帮助你，你先设置我最佳答案后，我百度Hii教你。

Java多线程程序设计初步入门

在Java语言产生前 传统的程序设计语言的程序同一时刻只能单任务操作 效率非常低 例如程序往往在接收数据输入时发生阻塞 只有等到程序获得数据后才能继续运行 随着Internet的迅猛发展 这种状况越来越不能让人们忍受 如果网络接收数据阻塞 后台程序就处于等待状态而不继续任何操作 而这种阻塞是经常会碰到的 此时CPU资源被白白的闲置起来 如果在后台程序中能够同时处理多个任务 该多好啊！应Internet技术而生的Java语言解决了这个问题 多线程程序是Java语言的一个很重要的特点 在一个Java程序中 我们可以同时并行运行多个相对独立的线程 例如 我们如果创建一个线程来进行数据输入输出 而创建另一个线程在后台进行其它的数据处理 如果输入输出线程在接收数据时阻塞 而处理数据的线程仍然在运行 多线程程序设计大大提高了程序执行效率和处理能力

线程的创建

我们知道Java是面向对象的程序语言 用Java进行程序设计就是设计和使用类 Java为我们提供了线程类Thread来创建线程 创建线程与创建普通的类的对象的操作是一样的 而线程就是Thread类或其子类的实例对象 下面是一个创建启动一个线程的语句

Thread thread =new Thread(); file://声明一个对象实例 即创建一个线程

Thread run(); file://用Thread类中的run()方法启动线程

从这个例子 我们可以通过Thread（）构造方法创建一个线程 并启动该线程 事实上 启动线程 也就是启动线程的run（）方法 而Thread类中的run（）方法没有任何操作语句 所以这个线程没有任何操作 要使线程实现预定功能 必须定义自己的run（）方法 Java中通常有两种方式定义run（）方法

通过定义一个Thread类的子类 在该子类中重写run（）方法 Thread子类的实例对象就是一个线程 显然 该线程有我们自己设计的线程体run（）方法 启动线程就启动了子类中重写的run（）方法

通过Runnable接口 在该接口中定义run（）方法的接口 所谓接口跟类非常类似 主要用来实现特殊功能 如复杂关系的多重继承功能 在此 我们定义一个实现Runnable（） 接口的类 在该类中定义自己的run（）方法 然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程

线程被实际创建后处于待命状态 激活（启动）线程就是启动线程的run（）方法 这是通过调用线程的start（）方法来实现的

下面一个例子实践了如何通过上述两种方法创建线程并启动它们

// 通过Thread类的子类创建的线程 　 class thread extends Thread { file://自定义线程的run()方法 　 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://通过Runnable接口创建的另外一个线程 class thread implements Runnable 　 { file://自定义线程的run()方法 public void run() { 　 System out println( Thread is running… ); } 　 } 　 file://程序的主类 　 class Multi_Thread file://声明主类 { 　 plubic static void mail(String args[]) file://声明主方法 { 　 thread threadone=new thread (); file://用Thread类的子类创建线程 　 Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程 　 threadone start(); threado start(); 方法启动线程 } 　 }

运行该程序就可以看出 线程threadone和threado交替占用CPU 处于并行运行状态 可以看出 启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类) 调用start()方法启动线程的run()方法不同于一般的调用方法 调用一般方法时 必须等到一般方法执行完毕才能够返回start()方法 而启动线程的run()方法后 start()告诉系统该线程准备就绪可以启动run()方法后 就返回start()方法执行调用start()方法语句下面的语句 这时run()方法可能还在运行 这样 线程的启动和运行并行进行 实现了多任务操作

线程的优先级

对于多线程程序 每个线程的重要程度是不尽相同 如多个线程在等待获得CPU时间时 往往我们需要优先级高的线程优先抢占到CPU时间得以执行 又如多个线程交替执行时 优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些 这样 高优先级的线程处理的任务效率就高一些

Java中线程的优先级从低到高以整数 ~ 表示 共分为 级 设置优先级是通过调用线程对象的setPriority()方法 如上例中 设置优先级的语句为

thread threadone=new thread (); file://用Thread类的子类创建线程

Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程

threadone setPriority( ); file://设置threadone的优先级

threado setPriority( ); file://设置threado的优先级

threadone start(); threado start(); 方法启动线程

这样 线程threadone将会优先于线程threado执行 并将占有更多的CPU时间 该例中 优先级设置放在线程启动前 也可以在启动后进行设置 以满足不同的优先级需求

线程的（同步）控制

一个Java程序的多线程之间可以共享数据 当线程以异步方式访问共享数据时 有时候是不安全的或者不和逻辑的 比如 同一时刻一个线程在读取数据 另外一个线程在处理数据 当处理数据的线程没有等到读取数据的线程读取完毕就去处理数据 必然得到错误的处理结果 这和我们前面提到的读取数据和处理数据并行多任务并不矛盾 这儿指的是处理数据的线程不能处理当前还没有读取结束的数据 但是可以处理其它的数据

如果我们采用多线程同步控制机制 等到第一个线程读取完数据 第二个线程才能处理该数据 就会避免错误 可见 线程同步是多线程编程的一个相当重要的技术

在讲线程的同步控制前我们需要交代如下概念

用Java关键字synchonized同步对共享数据操作的方法

在一个对象中 用synchonized声明的方法为同步方法 Java中有一个同步模型 监视器 负责管理线程对对象中的同步方法的访问 它的原理是 赋予该对象唯一一把 钥匙 当多个线程进入对象 只有取得该对象钥匙的线程才可以访问同步方法 其它线程在该对象中等待 直到该线程用wait（）方法放弃这把钥匙 其它等待的线程抢占该钥匙 抢占到钥匙的线程后才可得以执行 而没有取得钥匙的线程仍被阻塞在该对象中等待

file://声明同步的一种方式 将方法声明同步

class store　 {public synchonized void store_in(){… }public synchonized void store_out(){　 … }}

? 利用wait（） notify（）及notifyAll（）方法发送消息实现线程间的相互联系

Java程序中多个线程通过消息来实现互动联系的 这几种方法实现了线程间的消息发送 例如定义一个对象的synchonized 方法 同一时刻只能够有一个线程访问该对象中的同步方法 其它线程被阻塞 通常可以用notify（）或notifyAll（）方法唤醒其它一个或所有线程 而使用wait（）方法来使该线程处于阻塞状态 等待其它的线程用notify（）唤醒

一个实际的例子就是生产和销售 生产单元将产品生产出来放在仓库中 销售单元则从仓库中提走产品 在这个过程中 销售单元必须在仓库中有产品时才能提货 如果仓库中没有产品 则销售单元必须等待

程序中 假如我们定义一个仓库类store 该类的实例对象就相当于仓库 在store类中定义两个成员方法 store_in（） 用来模拟产品制造者往仓库中添加产品 strore_out（）方法则用来模拟销售者从仓库中取走产品 然后定义两个线程类 customer类 其中的run（）方法通过调用仓库类中的store_out（）从仓库中取走产品 模拟销售者 另外一个线程类producer中的run（）方法通过调用仓库类中的store_in（）方法向仓库添加产品 模拟产品制造者 在主类中创建并启动线程 实现向仓库中添加产品或取走产品

如果仓库类中的store_in（） 和store_out（）方法不声明同步 这就是个一般的多线程 我们知道 一个程序中的多线程是交替执行的 运行也是无序的 这样 就可能存在这样的问题

仓库中没有产品了 销售者还在不断光顾 而且还不停的在 取 产品 这在现实中是不可思义的 在程序中就表现为负值 如果将仓库类中的stroe_in（）和store_out（）方法声明同步 如上例所示 就控制了同一时刻只能有一个线程访问仓库对象中的同步方法 即一个生产类线程访问被声明为同步的store_in（）方法时 其它线程将不能够访问对象中的store_out（）同步方法 当然也不能访问store_in（）方法 必须等到该线程调用wait（）方法放弃钥匙 其它线程才有机会访问同步方法

lishixinzhi/Article/program/Java/gj/201311/27301

计算机软件技术基础浅谈论文

计算机软件技术基础是仿真工程与自动化专业的核心课程之一，该课程是整合课程，主要包括c++面向对象程序设计、算法与数据结构、操作系统、软件工程等方面的内容，知识庞杂且难以掌握。下面是我给大家推荐的计算机软件技术基础浅谈论文，希望大家喜欢!

计算机软件技术基础浅谈论文篇一

《计算机软件技术基础课程的案例建设》

摘要：案例教学能有效提高学生分析问题和解决问题的能力，是现代教育的常用教学方法之一。文章分析案例教学中的案例特征，以实际工程项目的一个子系统为背景，设计实时仿真监视系统案例并介绍案例的具体建设情况，指出该案例对提高学生的学习兴趣以及分析问题和解决问题的能力具有明显的效果。

关键词：软件技术基础;案例教学;案例建设;实时仿真;监视系统

1、计算机软件技术基础课程中案例教学的必要性

计算机软件技术基础是仿真工程与自动化专业的核心课程之一，是一门应用性很强的专业基础课。该课程是整合课程，主要包括c++面向对象程序设计、算法与数据结构、操作系统、软件工程等方面的内容，知识庞杂且难以掌握。学生在学习该课程之后常常感到困惑：所学知识有什么用，怎样运用所学知识?一些学生虽然能够在考试中考出高分，却不知道怎样解决实际问题。如何使学生认识所学知识的用途，融会贯通并灵活运用，是这门课应重点考虑的问题。目前，案例教学在法律类和管理类课程教学中的地位和作用已在教育界达成共识。教育部高等学校计算机科学与技术教学指导委员会于2006年6月发布了《关于进一步加强高等学校计算机基础教学的意见暨计算机基础课程教学基本要求(试行)》白皮书，明确指出在教学方法和手段上运用案例教学的必要性，因此，将案例教学作为一种教学方法引入工科类课程的教学，具有可行性和必要性。

2、认识案例

案例教学法就是在教师的指导下，根据教学目的和要求，以案例为基本素材，把学生带人特定的教学情境中进行思考，以此加深学生对基本原理和概念的理解，进而培养并提高学生运用理论知识分析问题和锯决问题能力的一种教学方法。

案例是案例教学的基础，离开了案例，案例教学就无从谈起。案例与一般教学中的例题有着本质区别，案例教学中的案例是将多个知识点融人一个整体来解决实际问题，涉及的知识面广，知识间具有连贯性和系统性，涵盖的知识具有综合性的特点，知识和原理蕴藏于案例之中。一般教学中的例题往往是配合某一章节或某一知识点，从某个角度、某个方面或某个层次反映所学理论和方法，起着验证和说明作用，常常带有为讲知识而杜撰例子的痕迹，各个例题之间相对独立，涵盖的知识单一，知识和原理孤立地呈现在学生面前。一般说来，工科类课程的案例应具有以下基本特征。

1)真实性。

客观真实性是案例的基本特征。教学案例应源于真实，取材于工程实际或科研课题，但是又要高于真实。为了突出主题，可以对真实做一定的删减处理。

2)综合性。

案例应是综合知识的载体，既要以学生已掌握的知识为依据辐射足够多的知识点，又要在匹配教学内容的基础上对知识有一定程度的扩展。

3)完整性。

案例是完整过程的载体，涉及了解背景、查询资料、分析信息、发现问题、探求方法、采取行动、解决问题的全过程。

4)启发性。

案例教学着眼于能力的培养，希望得到的不是案例的标准答案，而是解决问题的思维方法和能力。案例中，解决问题的方式是开放性的，可以留给学生想象的空间和发挥的余地。

5)实践性。

学生可以对案例进行复现、改进和完善，也可以按照自己的思考去实现，增强理论应用于实际的能力，实现从理论到实践的转化。

3、案例建设

案例教学的前提是高质量的案例，高质量的案例既要覆盖足够的知识，又要控制合适的规模。规模过小，则不能溶入足够的知识，也不能提供足够的研讨与思维空间;规模过大，则在短时间内难以被学生接受，不能得到预期的教学效果。笔者以实际工程项目卫星实时仿真系统的一个子系统为案例背景，在突出主题的前提下，进行了适当的详略及删减处理，形成了“实时仿真监视系统”案例。

3.1 案例背景简介

卫星实时仿真系统能够对卫星的方案、设计、集成、测试和运行各个阶段进行仿真验证，是提高卫星总体设计水平的重要手段，其网络关系连接如图1所示。在此系统中，仿真模型解算、物理设备接口等苛刻实时约束的节点通过反射内存互联，构成实时内环，外环则通过普通网络互联，将人机交互、可视化、数据处理等实时约束弱的节点互联，内、外环都可以根据需要扩充且内环不受外环影响，苛刻实时得到保障。转发计算机完成内存数据的提取并转发外环，仿真管理计算机则同时管理内、外环系统。卫星仿真监控是卫星实时仿真过程中的重要一环，它将抽象的仿真活动形象化，并及时将信号数据以各种方式反馈给用户，以利于用户分析、理解和决策。卫星实时仿真监控系统，能够模拟通过控制、监视和测量星上设备的工作状态实现实时连续地记录工作过程、测试数据和描绘曲线。图1中，人机交互计算机、曲线显示计算机和三维显示等外环计算机共同实现仿真监视功能。我们将人机交互计算机和曲线显示计算机的功能提取出来，要求系统具有一定的通用性，能够适应不同监视任务和不同数据类型，形成“实时仿真监视系统”案例。

3.2 实时仿真监视系统案例

实时仿真监视系统的工作原理为：转发计算机完成内存数据的提取并转发外环，外环上的实时仿真监视系统首先进行初始化，随后自动生成系统主界面。系统支持两种运行模式：监视模式和回放模式。在监视模式下，系统既要处理主界面信息，又要处理网络数据。主界面信息的处理包括响应用户交互消息、更新实时监视界面、实时绘制曲线;网络数据的处理包接监听网络端口，接收、解析和保存数据包，将有效数据写入共享数据结构，供给系统绘制曲线。在回放模式下，不再需要对网络进行监听，直接读取监视模式下保存的原始数据文件，然后进行相应处理即可。

为实现上述目的，使系统具有一定的通用性，我们设计了如下方案：

(1)在软件工程思想指导下，进行需求分析、总体设计、详细设计、编码实现以及综合测试。通过该案例，让学生对软件工程思想指导下的软件开发全过程有一个感性认识;

(2)采用多线程技术实现监视模式下的主界面信息处理和网络数据处理，仅用单线程实现回放模式;

(3)设计一个数据包发送测试程序，模拟转发计算机的功能。

为此，我们结合本课程的基本知识点将系统的主要功能模块划分为界面管理和数据处理两大部分，界面管理部分主要承担主界面信息的处理，数据处理部分则主要负责数据的处理。

3.2.1 界面管理

系统运行过程中始终需要对系统主界面进行管理。从运行初期的生成主界面，到运行中的监视过程的显示，再到最终的系统结束，都需要对主界面进行即时的调整。为了提高通用性，系统采用基于配置文件的方式，通过用户提供的配置文件，动态改变系统监视任务，也就是说，系统能够改变每次运行时的任务，主界面显示的内容具有不确定性。

1)读取配置文件，获取初始化信息。

系统运行之前，需要进行初始化，这就需要系统读取配置文件，包括全部信号、实时显示信号、数据包类型等配置文件。用户必须按照约定的正确格式提供配置文件，否则系统有可能无法正确识别相关信息。从软件工程的角度，配置文件的设计与确定应在总体设计阶段完成。配置文件的类型、组织方式以及数据正确性的检验，都是学生可以自由发挥和扩展的内容。

2)自动生成实时监视界面。

监视对象的不确定性使得系统的监视界面无法固定，然而，不能将界面的生成工作完全交给用户完成，这就需要设计一种适用于不同监视任务的界面生成算法，使系统将界面生成工作承担下来。另外，系统界面的尺寸等信息是用户所不知道的，因此被监视的信号在系统主界面中的显示位置无法由用户设定，这就需要系统自己完成界面的排布任务。因此，要求设计一个具有较强通用性的监视界面自适应生成算法，这部分涉及算法设计和计算机系统配置的获取等基础知识，算法设计是学生能够自由发挥并出彩的部分。

3)定时更新监视界面。

为了实现实时监视功能，系统需要对监视界面进行定时更新，以显示当前被监视信号的实时数据。为了满足用户的不同需求，系统提供0.5s、1s、2s三种刷新频率。系统可以根据用户选择的刷新频率对主界面进行更新。这部分主要涉及定时器的使用。

4)处理用户交互消息。

系统需要对用户的交互消息进行处理，主要为鼠标消息，包括运行模式的切换、仿真的开始与结束、加载历史数据包文件等。这部分涉及所选编程环境下的消息响应机制问题。

3.2.2 数据处理

系统在运行过程中，需要对数据包进行接收、解析和存储，还要为曲线绘制提供原始数据，因此需要设计一个专用的数据结构。

1)接收网络数据包。

在监控模式下，系统既要处理主界面信息，又要通过网络接收数据包。为了避免“漏掉”数据包，系统必须对网络持续进行监听。如果主线程将大量时间用在网络监听上，势必无法对用户的交互做出及时响应。因此，需要将数据包的接收放在一个单独的线程中。这涉及操作系统进程管理的相关概念，是多线程程序设计技术的典型应用;也涉及网络通信技术，需要了解网络通信协议等相关知识。

2)解析数据包。

在接收到数据包后，需要将数据包内的数据进行解析，获得数据包内的数据，将最新的数据更新至系统对应的变量中，以供实时显示。解析数据包涉及网络通信程序设计技术。

3)保存原始数据包。

系统要求有回放功能，因此需要将接收到的数据包写入文件，进行永久保存。数据包的保存有两种方式：解析后按段保存和作为整体进行二进制保存。第一种方法耗时，需较大工作量。第二种方法简便，工作量小。显然第二种方法更适合本系统。由于系统必须适应两种类型的数据包，因此，进行数据保存时，采用以形参类型为区别的方式进行同名函数的重载，实现两种类型数据包文件的存储。这部分功能涉及C++面向对象程序设计中的重载技术以及文件操作技术。

4)读取数据文件，获取数据包。

在回放模式下，系统不再对网络进行监听，不进行数据包的接收，需要通过读取之前保存的原始数据包文件获得数据包。原始数据包文件保存的是二进制形式的数据包，系统每次读取之后需要对数据包进行解析，这与接收到数据包的过程是一样的，不同之处在于回放过程不再需要将数据包进行保存。这涉及C++面向对象程序设计中的文件操作，同时，通过监视模式下的多线程程序设计与回放模式下的单线程程序设计的对比，使学生真切感受并理解多线程程序设计技术及其应用场合等。

5)共享数据。

系统嵌套了曲线绘制模块，因此，数据处理与曲线绘制之间需要有一块共享数据内存。在收到数据包并解析后，马上将有用的信息写入该共享内存。写入操作由数据包接收线程处理，读取操作由主线程内的曲线绘制模块完成，因此，需要对两个线程进行同步。这涉及数据结构的设计和操作系统的同步与互斥。

6)快速查找。

系统支持大数据量下的仿真监视，对数据的快速查找有较高的需求，因此，需要设计支持快速查找的哈希表数据结构，包括哈希函数的确定、冲突的解决等，这涉及数据结构的哈希表技术。

4、结语

“实时仿真监视系统”案例，涵盖了软件工程、c++面向对象程序设计、算法与数据结构、操作系统和网络通信等计算机软件技术基础课程及其先导与后继课程的知识点，是一个与学生所学专业密切相关的实际应用系统，容易引起学生的兴趣，也容易被学生理解和接受。这样的案例既与教学目标相吻合，又便于教师驾驭和把握。

从学生反馈的情况看，学生普遍认为，案例教学法方式新颖，实时仿真监视系统案例与专业基础结合紧密;能引导学生积极思考，提高学生的学习兴趣以及分析问题和解决问题的能力。该案例在教学过程中取得了明显的教学效果。

为了更好地开展案例教学，我们必须把建设高质量的案例作为重点来抓，选择合适的案例背景，制定合理的案例建设计划。实践证明，只有经过长时间的积累、认真的思考、精心的选择和多次教学实践，才能获得高质量的教学案例;只有经过团队的长期努力，才能建设高质量的教学案例库。

点击下页还有更多计算机软件技术基础浅谈论文 ?