JAVA 线程 异常 进程_Java练习题 - 线程&异常

练习一：多线程开启

问题：

请描述Thread类中的start()方法与run()方法的区别。

答：

线程对象调用run()方法不开启线程，仅是对象调用方法。线程对象调用start()方法开启线程，并让jvm调用run()方法在开启的线程中执行。

练习二：创建多线程

问题：

请描述创建线程的两种方式。

答：

第一种方式是将类声明为 Thread 的子类。

1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2.创建Thread子类的实例，即创建了线程对象。

3.调用线程对象的start()方法来启动该线程。

第二种方式是声明一个类实现Runnable 接口。

1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。

3.调用线程对象的start()方法来启动线程。

练习三：多线程练习

问题：

请编写程序，分别打印主线程的名称和子线程的名称。

要求使用两种方式实现：

第一种方式：继承Thread类。

第二种方法：实现Runnable接口。

答：

操作步骤描述

第一种方式：继承Thread类

1.定义一个子线程的类，继承Thread类；

2.在子线程类中重写run方法，在run方法中打印子线程的名称；

3.定义一个测试类；

4.在main方法中打印主线程的名称；

5.在main方法中创建子线程对象；

6.调用子线程对象的start方法，开启子线程；

第二种方式：实现Runnable接口

1.定义一个子任务类，实现Runnable接口；

2.在子任务类中重写run方法，在run方法中打印子线程的名称；

3.定义一个测试类；

4.在main方法中打印主线程的名称；

5.在main方法中创建一个子任务对象；

6.在main方法中创建一个Thread类的对象，并把子任务对象传递给Thread类的构造方法；

7.调用Thread类对象的start方法开启子线程；

操作步骤答案

第一种方式：继承Thread类

/*

* 1.定义一个子线程的类，继承Thread类；

*/

public class SubThread extends Thread {

/*

*2.在子线程类中重写run方法，在run方法中打印子线程的名称；

*/

public void run() {

// 打印子线程的名称

System.out.println("subThread:" + Thread.currentThread().getName());

}

}

/*

* 3.定义一个测试类

*/

public class ThreadDemo {

public static void main(String[] args) {

// 4.在main方法中打印主线程的名称；

System.out.println("main:" + Thread.currentThread().getName());

// 5.在main方法中创建子线程对象；

SubThread st = new SubThread();

// 6.调用子线程对象的start方法，开启子线程。

st.start();

}

}

第二种方式：实现Runnable接口

/*

* 1.定义一个子任务类，实现Runnable接口。

*/

public class SubRunnable implements Runnable {

@Override

public void run() {

// 2.在子任务类中重写run方法，在run方法中打印子线程的名称。

System.out.println("SubRunnable:"+ Thread.currentThread().getName());

}

}

/*

* 3.定义一个测试类。

*/

public class RunnableDemo {

public static void main(String[] args) {

// 4.在main方法中打印主线程的名称。

System.out.println("RunnableDemo:"+ Thread.currentThread().getName());

// 5.在main方法中创建一个子任务对象。

SubRunnable r = new SubRunnable();

// 6.在main方法中创建一个Thread类的对象，并把子任务对象传递给Thread类的 构造方法。

Thread t = new Thread(r);

// 7.调用Thread类对象的start方法开启子线程。

t.start();

}

}

练习四：实现Runnable接口的优势

问题：

请描述实现Runnable接口比继承Thread类所具有的优势：

答：

1.适合多个相同的程序代码的线程去共享同一个资源。

2.可以避免java中的单继承的局限性。

3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。

4.线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。

练习五：线程状态

问题：请描述在线程的生命周期中， 有几种状态呢 ?

答：

1.NEW(新建) 线程刚被创建，但是并未启动。

2.Runnable(可运行)

线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。

3.Blocked(锁阻塞)

当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。

4.Waiting(无限等待)

一个线程在等待另一个线程执行一个(唤醒)动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。

5.Timed Waiting(计时等待)

同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。

6.Teminated(被终止)

因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

练习六：异常的体系

问题：

1.请描述异常的继承体系

2.请描述你对错误(Error)的理解

3.请描述你对异常(Expection的理解)

4.请描述你对运行时异常(RuntimeException)的理解

答：

1.异常继承体系为：异常的根类是 java.lang.Throwable，其下有两个子类：

java.lang.Error 与 java.util.Exception 。而Exception又分为编译时期异常：checked异常，与运行时期异常：runtime异常。

2.Error:表示不可修复的恶性的错误，只能通过修改代码规避错误的产生，通常是系统级别的，所以很严重。

3.Exception:表示可修复的良性(相对于错误)的异常，异常产生后程序员可以并且应该通过代码的方式纠正，使程序继续运行，是必须要处理的。

4.运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。

练习七：throw与throws的区别

问题：

1.请描述throw的使用位置,作用是什么?

2.请描述throws的使用位置,作用是什么?

答：

1.throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。

2.throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。

练习八：异常的处理方式

问题：

1. 异常处理方式有几种,分别是什么?

2. 详细阐述每种方式对异常是如何处理的

答：

1.异常的处理方式有两种,分别是使用throws和try...catch...finally

2.throws用在方法的声明上后接异常类名,是把异常抛给调用者进行处理

3.try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行

a)try代码块中是可能出现异常的代码

b)catch代码块,是遇到异常,对异常进行处理的代码

c)finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.

练习九：常见异常，及产生原因

问题：请列举常见异常，并说明产生原因。

答：

NullPointerException:空指针异常。

当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度等等。

ArrayIndexOutOfBoundsException:数组索引越界异常。

当对数组的索引值为负数或大于等于数组大小时抛出此异常。

ArithmeticException:算术运算异常。

程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。

NumberFormatException:数字格式异常。

当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。

注意：答案不唯一，合理即可。

练习十：看代码，分析结果

问题：根据给出的相应代码，分析可能产生的结果。

1.举例：

public static void main(String[]args){

String str=null;

System.out.println(str.length());

}

答：变量str的值为null，调用方法时，报空指针异常NullPointerException

2.举例：

public static void main(String[]args){

int arr[]={1,2};

System.out.println(arr[2]);

}

答：索引值2大于等于数组arr的长度时，报数组索引越界异常ArrayIndexOutOfBoundsException

3.举例：

public static void main(String[]args){

System.out.println(1/0);

}

答：整数0做了分母，报算术运算异常ArithmeticException:/by zero

4.举例：

public static void main(String[]args){

System.out.println(Integer.parseInt("itcast"));

}

答：把字符串“itcast”转换为Integer类型时，当然会报数字格式化异常啦NumberFormatException

5.举例：

public static void main(String[] args) {

SimpleDateFormat format = new SimpleDateFormat("yyyy-mm-dd");

try {

Date date = format.parse("2018-04-03");

System.out.println("程序正常");

} catch (ParseException e) {

System.out.println("程序异常");

}

}

答：打印结果“程序正常”.try代码块中并没有产生异常，catch代码块中的代码不会执行。date为2018年1月3日00点04分00秒。

练习十一：并行、并发概念

问题：请简单描述什么是并行，什么是并发?

答：

并行：指两个或多个事件在同一时刻发生(同时发生)。

并发：指两个或多个事件在同一个时间段内发生。

通俗易懂版：

你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不 支持并行。

你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。

你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。

并发的关键是你有处理多个任务的能力，不一定要同时。

并行的关键是你有同时处理多个任务的能力。

所以它们最关键的点就是：是否是『同时』。

练习十二：进程概念、线程概念、线程与进程联系

问题：请描述什么是进程，什么是线程，进程与线程之间的关系，并举例说明。

答：

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程,但一个进程中至少包含一个线程。比如使用迅雷软件下载网络文件时，同时下载多个文件，就使用到了多线程下载。

练习十三：自定义异常类

问题：

请使用代码实现

每一个学生(Student)都有学号,姓名和分数,分数永远不能为负数

如果老师给学生赋值一个负数,抛出一个自定异常

答：

/*

1.定义异常类NoScoreException,继承RuntimeException

a)提供空参和有参构造方法

*/

public class NoScoreException extends RuntimeException {

// 空参构造

public NoScoreException() {

super();

}

// 有参构造

public NoScoreException(String message) {

super(message);

}

}

/*

2.定义学生类(Student)

a)属性:name,score

b)提供空参构造

c)提供有参构造;

i.使用setXxx方法给名称和score赋值

d)提供setter和getter方法

i.在setScore(int score)方法中

1.首先判断,如果score为负数,就抛出NoScoreException,异常信息为:分数不能为负数:xxx.

2.然后在给成员score赋值.

*/

public class Student {

private String name;

private int score;

// 空参构造

public Student() {

super();

}

// c)提供有参构造;

// i.使用setXxx方法给名称和score赋值

public Student(String name,int score){

setName(name);

setScore(score);

}

// d)提供setter和getter方法

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getScore() {

return score;

}

// i.在setScore(int score)方法中

public void setScore(int score) {

// 1.首先判断,如果score为负数,就抛出NoScoreException,异常信息为:分数不能为负数:xxx.

if(score <0){

throw new NoScoreException(":分数不能为负数:"+score);

}

// 2.然后在给成员score赋值.

this.score = score;

}

}

/*

3.定义测试类Test9

a)提供main方法,在main方法中

i.使用满参构造方法创建Student对象,分数传入一个负数,运行程序

ii.由于一旦遇到异常,后面的代码的将不在执行,所以需要注释掉上面的代码

iii.使用空参构造创建Student对象

iv.调用setScore(int score)方法,传入一个正数,运行程序

v.调用setScore(int score)方法,传入一个负数,运行程序

*/

public class Test9 {

public static void main(String[] args) {

// i.使用满参构造方法创建Student对象,分数传入一个负数,运行程序

// Student s = new Student("景甜", -10);

// ii.由于一旦遇到异常,后面的代码的将不在执行,所以需要注释掉上面的代码

// iii.使用空参构造创建Student对象

Student s = new Student();

// iv.调用setScore(int score)方法,传入一个正数,运行程序

s.setScore(100);

// v.调用setScore(int score)方法,传入一个负数,运行程序

s.setScore(-5);

}

}

练习十四：多线程

问题：

创建多线程对象，开启多线程。在子线程中输出1-100之间的偶数，主线程输出1-100之间的奇数。

答：

自定义线程类：

public class MyThread extends Thread {

/**

* 重写run方法，完成该线程执行的逻辑

*/

@Override

public void run() {

for (int i = 1; i <= 100; i++) {

if (i % 2 == 0) {

System.out.println("子线程打印输出偶数：" + i);

}

}

}

}

测试类：

public class Test11 {

public static void main(String[] args) {

//创建自定义线程对象

MyThread mt = new MyThread();

//开启线程

mt.start();

//在主方法中执行for循环

for (int i = 1; i <= 100; i++) {

if (i % 2 == 1) {

System.out.println("主线程打印输出奇数：" + i);

}

}

}

}