多线程异常处理

实验四多线程异常处理

1．实验目的

(1) 掌握Java的异常处理机制及相关实现方法能够在程序设计中熟练运用异常及相关类及对象；

(2) 掌握Java多线程的概念和实现方法；

(3) 掌握Java多线程的同步问题；

2．实验内容

实验题1创建两个线程，一个线程打印“A”，另一个线程打印“B”，比如ABBABAABBA….

实验代码：

package xuguigui;

public class SimpleThread extends Thread{

public SimpleThread(String name)

{

setName(name);

}

public void run(){

int i=0;

while(i++ <5){

try{

System.out.print(getName()+" ");

//Thread.sleep(1000);

}

catch(Exception e){

e.printStackTrace();

}

}

}

}

package xuguigui;

public class Xu {

public static void main(String[] args) {

SimpleThread thread1=new SimpleThread("A");

SimpleThread thread2=new SimpleThread("B");

thread1.start();

thread2.start();

}

}

程序运行结果：

实验题 2假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒买一张票。打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。输出格式如下：

第4售票点卖出第100张票

第2售票点卖出第101张票……

程序代码：

package xx;

public class testxx extends Thread {

int ticket = 200;

String name = "";

public void run() {

while (true) {

synchronized (name) {

if (ticket <= 0)

break;

System.out.println("第" +

Thread.currentThread().getName()

+ "售票点卖出第" + ticket-- + "张票");

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

package xx;

public class Ticket {

public static void main(String[] args){

testxx t = new testxx();

new Thread(t,"1").start();

new Thread(t,"2").start();

new Thread(t,"3").start();

new Thread(t,"4").start();

new Thread(t,"5").start();

new Thread(t,"6").start();

new Thread(t,"7").start();

new Thread(t,"8").start();

new Thread(t,"9").start();

new Thread(t,"10").start();

}

}

程序运行结果：

此题主要考察synchronized（）同步代码块的理解和使用。在程序中执行到synchronized设定的同步化区块时锁定当前对象，这样就没有其他线程可以执行这个被同步化的区块了。另，代码中调用了Thread类中的currentThread（）方法，返回对当前正在执行的线程对象的引用。

实验题3 假设某家银行，它可接受顾客的汇款，每做一次汇款，便可计算出汇款的总额。现有两个顾客，每人都分3次，每次100元将钱到入。试编写一个程序，模拟实际作业。程序如下：

class CBank

{ private static int sum=0;

public static void add(int n){

int tmp=sum;

tmp=tmp+n; // 累加汇款总额

try{

Thread.sleep((int)(10000*Math.random())); // 小睡几秒钟

}

catch(InterruptedException e){}

sum=tmp;

System.out.println("sum= "+sum);

}

}

class CCustomer extends Thread // CCustomer类，继承自Thread类

{ public void run(){ // run() method

for(int i=1;i<=3;i++)

CBank.add(100); // 将100元分三次汇入

}

}

public class Ex6_1

{ public static void main(String args[])

{ CCustomer c1=new CCustomer();

CCustomer c2=new CCustomer();

c1.start(); c2.start();

}

}

[基本要求] 运行程序5次，观察每次运行结果是否相同。

[思考问题] 程序运行结果每次是否相同，运行时间是否相同，为什么？

①要使程序运行结果每次相同，应该怎样修改程序？

将睡眠时间由原来的随机改成一个确定的毫秒数，比如sleep（100），则运行结果和运行时间就一样了。

②程序中为什么要使用异常处理？

执行sleep（）方法后，当前线程将休眠指定的时间段，如果任何一个线程中断了当前线程的休眠，该方法将抛出InterruptedException异常对象，所以在使用sleep（）方法时，必须捕获该异常。

实验题4在程序中主动产生一个ArithmeticException 类型被0 除的异常，并用catch 语句捕获这个异常。最后通过ArithmeticException 类的对象e 的方法getMessage 给出异常的具体类型并显示出来。

程序代码：

package xx;

public class Test {

public static void main(String[] arg3) {

System.out.println("这是一个异常处理的例子\n");

try {

int i = 10;

i /= 0;

} catch (ArithmeticException e) {

System.out.println("异常是：" + e.getMessage());

} finally {

System.out.println("finally 语句被执行");

}

}

}

程序运行结果：

实验题5在一个类的静态方法mathod（）方法内使用throw 产生异常，使用throws 子句抛出mathod（）的异常，在main 方法中捕获处理异常。

程序代码：

package xx;

public class Test2 {

static void throwProcess() {

try {

throw new NullPointerException("空指针异常");

} catch (NullPointerException e) {

System.out.println("\n 在 throwProcess 方法中捕获一个" +

e.getMessage());

throw e;

}

}

public static void main(String args[]) {

try {

throwProcess();

} catch (NullPointerException e) {

System.out.println("再次捕获：" + e);

}

}

}

程序运行结果：

实验题6在try 子句中设计两个以上可能出现的异常。通过多个catch 子句分别来捕获异常。并使用finally子句确保一段代码不管发生什么异常都能被执行。

程序代码：

package xx;

public class Catch {

public static void main(String[] args) {

int[] a = {1,2,3,4,5};

int[] b = {1,0,3,0};

for(int i=0;i

try {

System.out.println(a[i]/b[i]) ;

} catch (ArrayIndexOutOfBoundsException m) {

System.out.println("数组下表越界！");

System.out.println("错误：" + m.getMessage());

} catch (RuntimeException e) {

System.out.println("除数不能为零！");

System.out.println("错误：" + e.getMessage());

// TODO Auto-generated catch block

} finally {

System.out.println("finally后面的语句永久打印！");

}

}

}

程序运行结果：

实验题7 编写一个程序，输入一个班某门课程成绩，统计及格人数、不及格人数平均分。为此设计一个异常类，当输入的成绩小于0分或大于100分时，抛出异常，程序将捕捉这个异常，并作出相应处理。

[基本要求] 编写完整程序

程序代码：

package xx;

class MinusException extends ArithmeticException {

public MinusException() {

}

public MinusException(String str) {

super(str);

}

}

package xx;

class OverException extends ArithmeticException {

public OverException() {

}

public OverException(String str) {

super(str);

}

}

package xx;

import java.util.*;

public class TestScore {

public static void judgescore(int i) throws MinusException, OverException {

if (i < 0)

throw new MinusException("分数不能为负数");

if (i > 100)

throw new OverException("分数超过100，过大!");

}

public static void main(String[] args) {

int array[] = { 0, 0 };

int turn = 1;

double total = 0;

Scanner input = new Scanner(System.in);

int score = 0;

System.out.println("请输入学生成绩,输入-1退出:");

System.out.print("请输入" + turn + "个学生成绩:");

score = input.nextInt();

while (score != -1) {

try {

judgescore(score);

if (score < 60)

++array[0];

if (score >= 60)

++array[1];

total += score;

} catch (MinusException e1) {

System.err.println(e1+"\n");

} catch (OverException e2) {

System.err.println(e2+"\n");

} catch (ArithmeticException e3) {

System.err.println("其它异常"+"\n");

}

turn++;

System.out.print("请输入" + turn + "个学生成绩:");

score = input.nextInt();

}

System.out.println("不及格人数：" + array[0]);

System.out.println("及格人数：" + array[1]);

System.out.println("平均分：" + total / (array[0] + array[1]));

}

}

程序运行结果：

实习总结：

本次实习遇到困难不少，对书本不够熟悉。