Java | 世昱的blog

Java

编程语言

发布日期: 2022-11-20

更新日期: 2022-11-22

文章字数: 3.7k

阅读时长: 15 分

阅读次数:

1 Java多线程

1.1 并发和并行

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

对于单CPU系统，并发不能同时处理。只能单CPU不同时地处理多个任务。

对于多CPU系统，可以多CPU处理并行。多CPU同时处理多任务

1.2 进程和线程

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

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.3 创建多线程(代码实现)

java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

两种创建线程的方式：

方式一：继承Thread类。

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

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

通过main线程和自定义线程各有一个for来查看多线程运行状况

测试线程的main方法：

package NewDemos;

public class DemoTest {
    public static void main(String[] args) {
        MyThreads myThreads=new MyThreads();
        myThreads.start();//与myThreads.run();完全不同
//        在main方法中的for
        for (int i = 0; i < 9; i++) {
            System.out.println("main"+i);
        }
    }
}

测试线程的自定义的线程类：

package NewDemos;

public class MyThreads extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 9; i++) {
            System.out.println("MyThread"+i);
        }
    }
}

输出结果：

main0
MyThread0
main1
MyThread1
main2
MyThread2
main3
MyThread3
MyThread4
MyThread5
MyThread6
MyThread7
main4
MyThread8
main5
main6
main7
main8

也许是我的大白太优秀了，试了好几次竟然没有穿插的，hhhhhhh

方式二：实现Runable接口

步骤：

1.创建Runable接口的实现类

2.在实现类中重写Runable接口的run方法，实现线程任务

3.创建一个Runable实现类的对象。

4.创建Thread类对象，创建的同时将3中Runable实现类的对象放到Thread构造方法中。

5.调用Tread对象中的strat方法，开启新线程

示例：

mian方法中：

package NewDemos;
public class DemoTest {
//    多线程实现第二种方式：实现Runable接口
public static void main(String[] args) {
    runableimpl runableimpl01=new runableimpl();
    Thread mythred=new Thread(runableimpl01);
    mythred.start();
    for (int i = 0; i < 9; i++) {
        System.out.println("main:"+i);
    }
}

实现Runable接口的实现类runableimpl

package NewDemos;

public class runableimpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 9; i++) {
            System.out.println("runable:"+i);
        }
    }
}


以上结果；
main:0
runable:0
main:1
runable:1
main:2
runable:2
runable:3
runable:4
main:3
runable:5
main:4
runable:6
main:5
runable:7
main:6
runable:8
main:7
main:8

2 异常

2.1 异常体系

异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

2.1.1 Exception

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常

编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

编译期异常(有”错误”的正确示例代码)：

package NewDemos;

import java.text.SimpleDateFormat;
import java.util.Date;
public class DemoTest {
    public static void main(String[] args) {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyy-MM-dd");
        Date date = simpleDateFormat.parse("2022-11-20");//parse本身含有异常
        System.out.println(date);
    }
}

编译期异常：

两个解决办法：

throws XXXXException

try catch

解决法一：在方法体中throws XXXXException（应该带有异常）

package NewDemos;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DemoTest {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyy-MM-dd");
        Date date = simpleDateFormat.parse("2022-11-20");
        System.out.println(date);
    }
}


结果：
Sun Nov 20 00:00:00 GMT+08:00 2022

测试方法一：

package NewDemos;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DemoTest {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyy-MM-dd");
        Date date = simpleDateFormat.parse("2022-11月20");
        System.out.println(date);
        System.out.println("后续代码");//在方法体中throws ParseException不会执行后续代码
    }
}

结果：
Exception in thread "main" java.text.ParseException: Unparseable date: "2022-11月20"
    at java.text.DateFormat.parse(DateFormat.java:366)
    at NewDemos.DemoTest.main(DemoTest.java:9)

解决方法二：try catch

package NewDemos;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DemoTest {
    public static void main(String[] args)  {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyy-MM-dd");
        Date date = null;
        try {
            date = simpleDateFormat.parse("2022-11月20");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);
        System.out.println("后续代码");//try catch抛出异常之后，会继续执行后续代码。
    }
}

结果：
java.text.ParseException: Unparseable date: "2022-11月20"
    at java.text.DateFormat.parse(DateFormat.java:366)
    at NewDemos.DemoTest.main(DemoTest.java:11)
null
后续代码

运行期异常

解决办法：

运行期异常示例：

package NewDemos;
public class DemoTest {
    public static void main(String[] args)  {
        int[] arr={98,6,5,3,45};
        System.out.println(arr[5]);
        System.out.println("后续代码");//打印不到后续代码
    }
}


结果（只有执行才报错。）：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
    at NewDemos.DemoTest.main(DemoTest.java:9)

解决办法：try catch （tips：ctrl+alt+T可快速插入）

package NewDemos;
public class DemoTest {
    public static void main(String[] args)  {
        int[] arr={98,6,5,3,45};
        try {
            System.out.println(arr[5]);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("后续代码");//可执行到后续代码
    }
}
结果：
java.lang.ArrayIndexOutOfBoundsException: 5
    at NewDemos.DemoTest.main(DemoTest.java:6)
后续代码

2.2 异常的处理

throw抛出（用在方法内）

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。具体操作：

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

throw抛出示例一：数组越界异常

package NewDemos;
public class DemoTest {
    public static void main(String[] args) {
        int[] arr = {98, 6, 5, 3, 45};//定义一个数组
        int index = 5;//定义超过数组长度的角标
        int element =getelementMethod(arr,index);//调用方法。
    }

    private static int getelementMethod(int[] arr,int index) {
        if (index > arr.length-1 || index < 0) {
            throw new ArrayIndexOutOfBoundsException("数组越界喽~");//使用throw抛出
        }
        int element=arr[index];
        return element;
    }
}

throw抛出示例二：空指针异常（objects的非空判断）

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

throws抛出（用在方法上）

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

示例一：

package NewDemos;
import java.io.FileNotFoundException;
public class DemoTest {
    public static void main(String[] args) throws FileNotFoundException {
        readfilesMethed("b.txt");
    }

    public static void readfilesMethed(String filepath) throws FileNotFoundException {
        if (!filepath.equals("a.txt")){
            throw  new FileNotFoundException("文件不存在噢~");
        }
    }
}
结果：
Exception in thread "main" java.io.FileNotFoundException: 文件不存在噢~
    at NewDemos.DemoTest.readfilesMethed(DemoTest.java:10)
    at NewDemos.DemoTest.main(DemoTest.java:5)

示例二：throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

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

    public static void read(String path)throws FileNotFoundException, IOException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

IOException是FileNotFoundException的父类，只写IOException即可，可自动识别处理。

try catch

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

示例一：

package NewDemos;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DemoTest {
    public static void main(String[] args) throws IOException {
        try {
            readfilesMethed("b.txt");
        } catch (FileNotFoundException e) {
            //try中抛出的是什么异常，在括号中就定义什么异常类型
            System.out.println(e);
        }
    }

    public static void readfilesMethed(String filepath) throws FileNotFoundException {
        if (!filepath.equals("a.txt")){
            throw  new FileNotFoundException("文件不存在噢~");
        }
    }
}

结果：
java.io.FileNotFoundException: 文件不存在噢~

如何获取异常信息：

Throwable类中定义了一些查看方法:

public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。

public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

示例：

package NewDemos;
import java.io.FileNotFoundException;
import java.io.IOException;

import static jdk.nashorn.internal.objects.NativeError.printStackTrace;

public class DemoTest {
    public static void main(String[] args) throws IOException {
        try {
            readfilesMethed("b.txt");
        } catch (FileNotFoundException e) {
            //try中抛出的是什么异常，在括号中就定义什么异常类型
            System.out.println("++++++++++++++++++++++++");
            System.out.println(e.getMessage());
            System.out.println("++++++++++++++++++++++++");
            System.out.println(e.toString());
            System.out.println("++++++++++++++++++++++++");
            e.printStackTrace();
        }
    }
    public static void readfilesMethed(String filepath) throws FileNotFoundException {
        if (!filepath.equals("a.txt")){
            throw  new FileNotFoundException("文件不存在噢~");
        }
    }
}
结果：
++++++++++++++++++++++++
文件不存在噢~
++++++++++++++++++++++++
java.io.FileNotFoundException: 文件不存在噢~
++++++++++++++++++++++++
java.io.FileNotFoundException: 文件不存在噢~
    at NewDemos.DemoTest.readfilesMethed(DemoTest.java:24)
    at NewDemos.DemoTest.main(DemoTest.java:10)

注意事项：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

finally

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？：当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

 try...catch....finally:自身需要处理异常,最终还得关闭资源。

示例：

package NewDemos;
import java.io.FileNotFoundException;
import java.io.IOException;

import static jdk.nashorn.internal.objects.NativeError.printStackTrace;

public class DemoTest {
    public static void main(String[] args) throws IOException {
        try {
            readfilesMethed("b.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally {
            System.out.println("不管程序怎样，这里都将会被执行。");
        }
        System.out.println("结束");
    }
    public static void readfilesMethed(String filepath) throws FileNotFoundException {
        if (!filepath.equals("a.txt")){
            throw  new FileNotFoundException("文件不存在噢~");
        }
    }
}
结果：
java.io.FileNotFoundException: 文件不存在噢~
    at NewDemos.DemoTest.readfilesMethed(DemoTest.java:21)
    at NewDemos.DemoTest.main(DemoTest.java:10)
不管程序怎样，这里都将会被执行。
结束

2.3 自定义异常*

自定义异常的场景原因：

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

定义一个异常类RegisterException

package NewDemos;

/*

* 定义一个自定义的异常类RegisterException

* */

public class RegisterException extends Exception{

    public RegisterException() {

    }

    public RegisterException(String message) {

        super(message);

    }

}

使用RegisterException

package NewDemos;
import javax.security.auth.login.LoginException;

public class DemoTest {
    // 模拟数据库中已存在账号名称
    private static String[] names = {"张三","李四","王五"};

    public static void main(String[] args)  {
        try{
            checkUsername("张三");//可能会出现异常的代码
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(RegisterException e){
            e.printStackTrace();//处理异常
        }
    }
    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws  RegisterException {
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲，"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

李世昱

https://lishiyu.vip/2022/11/20/java/