Java基础知识回顾第九篇 - Java异常机制 | 认识多线程

1、Java异常机制(Exception和Error)

我们先通过下面的一张图看看java异常层次结构：

 从图中可以看出，不管是Exception还是Error，它们都继承自Throwable。下面我们来分别认识一下Exception和Error。

 

总的来说的，Exception和Error是一种不正常的行为，或许是程序本身导致的，也或许是系统导致的。

Exception：可以是被控制的或不可被控制的异常，由程序员导致的，需要在应用程序中进行处理。

Error：总是不可控制的错误，是系统错误或低层资源的错误；如果可能的话，需要在系统级别进行处理。

 

发生异常了怎么办？

需要异常处理，就是把程序从异常中恢复过来，通过两种方式：一种是使用try-catch块进行捕捉，另一种是使用throws关键字抛出，由具体调用方去进行处理。

 

另外还有一个容易让人混淆的区分：checked异常和unchecked异常，那么如何理解呢？

checked Exception：受检查异常，需要try-catch或throws处理的异常；

unchecked Exception：不受检查异常，不需要try-catch或throws处理的异常，包括Error、RuntimeException以及其子类；

 

常见的几种RuntimeException(运行时异常)：

NullPointerExceptionextends；IndexOutOfBoundsException，ArrayIndexOutOfBoundsException，StringIndexOutOfBoundsException；IllegalArgumentException，NumberFormatException；ClassCastException；ArithmeticException

 

2、多线程的简单认识

认识多线程，我们需要先区分开进程和线程的区别。

进程：进行中的程序，其实就是一个应用程序运行时的内存分配空间。

线程：进程中一个程序执行控制单元，一条执行路径。

 

那么什么是多线程应用程序呢？当一个进程中出现多个线程的时候。

 

创建线程的三种方式：

第一种：继承Thread类，重写父类run方法，调用start()方法开启线程执行run()方法。

package com.tu.test.thread;

 

public class ThreadTest1 extends Thread{

//重新run方法，正在的线程执行主体

public void run(){

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

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

}

}

 

 

public static void main(String[] args) {

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

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

if (i == 10)

new ThreadTest1().start();

}

}

 

}

 

第二种：实现Runnable接口，覆盖run方法。

package com.tu.test.thread;

 

public class ThreadTest2 implements Runnable {

/**

*重新run方法，正在的线程执行主体

*/

public void run(){

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

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

}

}

 

 

public static void main(String[] args) {

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

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

if (i == 10) {

new Thread(new ThreadTest2(),"新线程").start();

}

}

}

 

}

 

第三种：通过Callable和Future创建线程

package com.tu.test.thread;

 

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

 

public class ThreadTest3 implements Callable<Integer> {

/**

*线程执行体

*/

@Override

public Integer call() throws Exception {

int i = 0;

for (;i<10;i++){

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

}

return i;

}

 

public static void main(String[] args) {

ThreadTest3 tt3 = new ThreadTest3();

FutureTask<Integer> task = new FutureTask<Integer>(tt3);

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

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

if (i == 10) {

new Thread(task,"有返回值的线程").start();

}

}

 

try {

System.out.println("子线程的返回值为：" + task.get());

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

}

 

}

 

 

既然是多线程，那么肯定会有线程安全的问题，对于同一个共享资源，多个线程同时访问就会出现问题。最简单的方式就是通过同步机制，使用synchronized来控制线程安全，这是一种隐式的锁操作。