异常及其处理、简单了解线程，创建线程、线程安全

本文链接：https://blog.csdn.net/qq_51257284/article/details/109188178

一、异常

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。

1.1 异常的分类

编译时期异常:在编译时期,就会检查,如果没有处理异常,则编译失败。
运行时期异常:在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。
Throwable体系：
Error:严重错误Error，无法通过处理的错误，只能事先避免。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

public void printStackTrace() :打印异常的详细信息。包含了异常的类型,异常的原因,还包括异常出现的位置。
public String getMessage() :获取发生异常的原因。提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。

1.2 异常的处理

1.2.1 抛出异常throw

关键字throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
使用格式： throw new 异常类名(参数);
如：

throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

1.2.2 Objects非空判断

Objects类中的一些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），在它的源码中，对对象为null的值进行了抛出异常操作。

//源码：
public static <T> T requireNonNull(T obj) {
    if (obj == null)
       throw new NullPointerException();  
    return obj;
}

1.2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者。
如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。关键字throws运用于方法声明上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常的格式：
修饰符返回值类型方法名(参数) throws 异常类名1,异常类名2…{ }
（throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。）

public static void main(String[] args) throws FileAlreadyExistsException {
    read("a.txt");
}

private static void read(String s) throws FileAlreadyExistsException {
    if(!s.equals("a.txt")){
        throw new FileAlreadyExistsException("文件不存在！");
    }
    System.out.println("文件存在");
}

1.2.4 捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。
格式如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
}

public static void main(String[] args)  {
    try {
        read("b.txt");
    } catch (FileAlreadyExistsException e) {
        System.out.println(e.getMessage());//获取异常的描述信息（自己写的参数）,提示给用户。
    }
    System.out.println("over");
}

private static void read(String s) throws FileAlreadyExistsException {
    if(!s.equals("a.txt")){
        throw new FileAlreadyExistsException("不存在！");
    }
}
结果：
不存在！
over

1.2.5 finally代码块

finally：在finally代码块中存放的代码无论异常是否发生都是一定会被执行的。
finally的语法:
try…catch…finally:自身需要处理异常,最终还得关闭资源

        try {
            read("a.txt");
        } catch (FileNotFoundException e) {
            //抓取到的是编译期异常  抛出去的是运行期
            throw new RuntimeException(e);
        } finally {
            System.out.println("不管程序怎样，这里都将会被执行。");
        }
        System.out.println("over");
    }

1.2.6 注意事项

多个异常使用捕获

多个异常分别处理。
多个异常一次捕获，多次处理。
多个异常一次捕获一次处理。
一次捕获多次处理格式：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码一
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码二
}

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况.
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

1.3 自定义异常

异常类定义:

自定义一个编译期异常: 自定义类并继承于 java.lang.Exception
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException 。

public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }
    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

二、线程

2.1 并行与并发

并发：指两个或多个事件在同一个时间段内发生。（多个任务之间交替运行）
并行：指两个或多个事件在同一时刻发生（同时发生）。

2.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

2.3 多线程原理

程序启动运行 main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

2.4 Thread类

构造方法：

public Thread() :分配一个新的线程对象
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行;
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

2.5 创建线程类

（1）通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

//自定义线程类
public class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName() + i);
        }
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread mt = new MyThread("新的线程：");
        mt.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main线程：" + i);
        }
    }
}

（2）创建线程类方式二：采用 java.lang.Runnable ，步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 8; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }

    }
}

//测试类
public class MyThreadTest {
    public static void main(String[] args) {
        Runnable mr = new MyRunnable();
        Thread t = new Thread(mr,"啦啦啦");
        t.start();
        for (int i = 0; i < 8; i++) {
            System.out.println("main线程：" + i);
        }
    }
}

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的

2.6 Thread与Rannable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现Runable接口很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：
适合多个相同的程序代码的线程去共享同一个资源。
避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

三、线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。例如卖票，多个窗口同时卖票，多人同时争夺使得票数发生错误可能多人买的是同一张票或票数变为负数，这就是不安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全

3.1 线程同步

同步机制(synchronized)来解决上述多线程并发访问一个资源的安全性问题。

有三种方式完成同步操作：
1 . 同步代码块。
2. 同步方法。
3. 锁机制

3.2 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
同步锁：

锁对象可以是任意类型。
多个线程对象要使用同一把锁

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着

public class Ticks implements Runnable{
    int tickets = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj){
                if(tickets > 0){
                    System.out.println((Thread.currentThread().getName() + ":" + tickets));
                    tickets--;
                    try {
                        Thread.sleep(50);//强制线程休眠，减慢线程。减少“线程执行太快，现象不明显”的现象
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else
                    break;
            }
        }
    }
}

public class TicksTest {
    public static void main(String[] args) {
        Ticks tick = new Ticks();
        Thread t1 = new Thread(tick,"窗口一正在卖");
        Thread t2 = new Thread(tick,"窗口二正在卖");
        Thread t3 = new Thread(tick,"窗口三正在卖");
        t1.start();
        t2.start();
        t3.start();
    }
}

3.3 同步方法

同步方法 :使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

public synchronized void method(){
   可能会产生线程安全问题的代码 //与同步代码块相比，就是将同步代码块中的东西放到了synchronized修饰的方法中。
}

3.4 Lock锁

同步代码块/同步方法具有的功能Lock都有,除此之外更强大。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

四、线程状态

在这里插入图片描述

public class WaitingTest {
    public static Object obj = new Object();

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        System.out.println(Thread.currentThread().getName() + "进入等待");
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();

                    }System.out.println(Thread.currentThread().getName()+"被唤醒");
                    for (int i = 0; i < 5; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                    }
                }
            }
        },"啦啦啦").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        System.out.println(Thread.currentThread().getName() + "进入等待");
                        Thread.sleep(100);//等待100毫秒后自动解锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"被唤醒");
                    for (int i = 0; i < 5; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                    }
                    obj.notify();
                }
            }
        },"略略略").start();
    }
}

执行结果：
啦啦啦进入等待
略略略进入等待
略略略被唤醒
略略略: 0
略略略: 1
略略略: 2
略略略: 3
略略略: 4
啦啦啦被唤醒
啦啦啦: 0
啦啦啦: 1
啦啦啦: 2
啦啦啦: 3
啦啦啦: 4