JVAV第八次实验：多线程与异常处理

一、实验目的：

了解线程的概念、线程的生命周期，掌握多线程的编程。掌握异常的概念以及如何定义、抛出和捕捉处理异常。

二、实验环境：

Windows下java SE。

三、实验内容：

（一）Thread子类的方法实现多线程

1．编写 TwoThreadsTest.java 程序文件，源代码如下。

class SimpleThread extends Thread {

public SimpleThread(String str) {

super(str);

}

public void run() {

for (int i = 0; i < 10;i++) {

System.out.println(i + "" + getName());

try {

sleep((int)(Math.random() *1000));

} catch (InterruptedException e){}

}

System.out.println("DONE! "+ getName());

}

public class TwoThreadsTest {

public static void main (String[] args) {

new SimpleThread("Go to Beijing??").start();

new SimpleThread("Stayhere!!").start();

}

2．编译、运行

3．请将程序的运行结果写在实验报告中。

4． 0 Go to Beijing??

5． 0 Stay here!!

6． 1 Go to Beijing??

7． 1 Stay here!!

8． 2 Go to Beijing??

9． 3 Go to Beijing??

10． 2 Stay here!!

11． 3 Stay here!!

12． 4 Go to Beijing??

13． 4 Stay here!!

14． 5 Go to Beijing??

15． 5 Stay here!!

16． 6 Go to Beijing??

17． 7 Go to Beijing??

18． 6 Stay here!!

19． 8 Go to Beijing??

20． 7 Stay here!!

21． 9 Go to Beijing??

22． 8 Stay here!!

23． DONE! Go to Beijing??

24． 9 Stay here!!

25． DONE! Stay here!!

（二）实现Runnable接口的方法实现多线程

1．程序功能：一个时钟Applet，它显示当前时间并逐秒进行更新

2．编写Clock.java 程序文件，源代码如下。

import java.awt.*;

import java.applet.*;

importjava.util.*;

public class Clock extends Applet implementsRunnable{

ThreadclockThread;

public void start(){

if(clockThread==null){

clockThread=newThread(this,"Clock");

clockThread.start();

}

public void run(){

while(clockThread !=null){

repaint();

try{

clockThread.sleep(1000);

}catch(InterruptedExceptione){}

}

public void paint(Graphics g){

Date now=new Date(); g.drawString(now.getHours()+";"+now.getMinutes()+";"+now.getSeconds(),5,10);

}

public void stop(){

clockThread.stop();

clockThread=null;

}

3．编译Clock.java 文件。

4．编写Clock.html 文件，源代码如下：
<HTML>

<HEAD>

<TITLE>A Simple Program </TITLE>

</HEAD>

<BODY>

Hereis the output of my program:

<APPLETCODE="Clock.class" WIDTH=150HEIGHT=25>

</APPLET>

</BODY>

</HTML>

5．在浏览器中打开Clock.html 文件，将你看到的运行结果写在实验报告中。

（三）捕获并处理各种类型的异常

1．编写ExceptionTest.java 程序文件，源代码如下。
import java.io.*;
public class ExceptionTest{
        public static void main(Stringargs[]) {
              for(int i = 0; i < 4;i++) {
                     int k;
                     try {
                           switch( i ) {
                                   case 0:
                                          int zero = 0;
                                          k = 911 / zero;
                                          break;
                                   case 1:
                                          int b[ ] = null;
                                          k = b[0];
                                          break;
                                   case 2:
                                          int c[ ] = new int[2];
                                          k = c[9];
                                          break;
                                   case 3:
                                          char ch = "abc".charAt(99);
                                          break;
                            }
                     }catch(Exception e) {
                            System.out.println("\nTestcase #" + i + "\n");
                            System.out.println(e);
                     }
              }
        }
}

2．编译、运行

Testcase#0

java.lang.ArithmeticException: / by zero

Testcase#1

java.lang.NullPointerException

Testcase#2

java.lang.ArrayIndexOutOfBoundsException:9

Testcase#3

java.lang.StringIndexOutOfBoundsException:String index out of range: 99

4．根据运行结果，请在实验报告中说明程序运行中总共捕捉了几个异常，并指出每个异常各自属于哪种类型的异常？

4个异常。java.lang.ArithmeticException

java.lang.NullPointerException

java.lang.ArrayIndexOutOfBoundsException

java.lang.StringIndexOutOfBoundsException。

（四）了解异常处理模块中各个语句块的功能

1．编写TryTest.java 程序文件，源代码如下。

importjava.io.*;
public class TryTest{
        public TryTest(){
              try{
                     int a[] = new int[2];
                     a[4] = 3;
                     System.out.println("After handling exception return here?");
              }catch(IndexOutOfBoundsException e){
                     System.err.println("exception msg:" + e.getMessage());
                     System.err.println("exception string:" + e.toString());
                     e.printStackTrace();
              }finally{
                     System.out.println("-------------------");
                     System.out.println("finally");
              }
              System.out.println("No exception?");
        }
        public static void main(Stringargs[]){
              new TryTest();
        }
}

2．编译、运行

3．根据运行结果，将程序的运行结果写在实验报告中。

exception msg:4

exception string:java.lang.ArrayIndexOutOfBoundsException: 4

java.lang.ArrayIndexOutOfBoundsException: 4

atTryTest.<init>(TryTest.java:6)

atTryTest.main(TryTest.java:19)

-------------------

finally

No exception?

4．请在实验报告中指出程序中的语句System.out.println("Afterhandling exception return here?"); 有没有被执行？

没有。

思考题

1．简述并区分程序、进程和线程三个概念。

程序 是计算机指令的集合它，以文件的形式存储在磁盘上。
进程是一个程序在其 自身的地址空间中的一次执行活动。
进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源，而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占系统的运行资源。
线程：进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
线程又称轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

2．线程有哪几个基本的状态？Java中线程调度遵循何种原则？

新建、运行、中断、死亡。同时进入看优先级谁高，相同优先级看操作系统如何调（有多种算法，系统先调谁不知道）
不同时进入需等前面线程阻塞或等待是进入运行状态

3．实现多线程可以用哪两种基本方法？将这两种方法进行比较。

一是直接继承Thread类，二是实现Runnable接口。

第一种：可以在子类中增加新的成员变量，使线程具有某种属性，也可以在子类中新增加方法，使线程具有某种功能。

第二种：可以共享相同的内存单元，并利用这些共享的单元来实现数据交换、实时通讯与必要的同步操作。

4．异常是如何抛出、捕捉和处理的？

抛出异常是方法中声明该方法可能出现的异常状态，利用throws关键字，捕获异常是在已知方法中会产生，或不完全确定，但是可能会产生异常的情况下，对能产生异常的代码部分进行的try catch处理。

5．异常处理机制有哪些好处？

Java 的"异常机制"就是在处理各类问题时给了程序员非常简单而灵活的方式。一般来说，其它高级语言主要是让函数使用者来关注该函数可能会出现的异常情况，而 java则是把这件事情交给方法的设计者来做。这对于方法的使用者来说带来的方便是不会因为责任心不强，或者办事丢三那四，会忘了在使用方法时处理可能发生的异常情况。