Java学习第十七天

最新推荐文章于 2024-05-28 16:05:50 发布

The_______shy

最新推荐文章于 2024-05-28 16:05:50 发布

阅读量235

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/The_______shy/article/details/111147081

版权

Java学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java学习第十七天

第一章异常
第二章多线程

第一章异常

1.1 异常概述

异常的定义：
指的是程序在执行过程，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常体系：
异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,该类下面有两个子类java.lang.Error和java.lang.Exception。我们平常说的异常是指Exception，其分为两种类别：

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

注意：

Error是我们所无法处理的类型,只能事先避免
Exception是可以处理的异常

1.2 异常产生过程的解析

首先看下面代码

public class Demo02Exception {
    public static void main(String[] args) {
        //  创建int类型数组,并赋值
        int[] arr = {1,2,3};
        int e = getElement(arr,3);
        System.out.println(e);
    }

    /*
        定义一个方法,获取数组指定索引处的元素
        参数:
            int[] arr
            int index
     */
    public static int getElement (int[] arr,int index){
        int ele = arr[index];
        return ele;
    }
}

很明显,上面代码会报错,异常类型为ArrayIndexOutOfBoundsException,究其根本是创建了一个ArrayIndexOutOfBoundsException异常类对象，其处理逻辑如下所示：
在这里插入图片描述

1.3 异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

1.3.1 throw关键字抛出异常对象

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

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

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

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

使用格式：

throw new 异常类名(参数);

注意事项：

throw关键字必须写在方法的内部
throw关键字后面new的对象必须是Exception或Exception的子类对象
throw关键字抛出指定的异常对象(分为运行期异常和编译异常,然而这两种异常都一定是Exception或Exception的子类对象),我们就必须处理这个异常对象
throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理（打印异常对象,中断程序运行）
throw关键字后边如果创建的是编译异常（写代码的时候报错）,我们就必须处理这个异常,要么throws交给别人处理,要么try…catch

通过以下代码演示throw的使用

public class Demo03Throw {
    /*
      定义一个方法,获取数组指定索引处的元素
      参数:
          int[] arr
          int index
      以后（工作中）我们首先必须对方法传递过来的参数进行合法性检验
      如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传入的参数有问题


      注意：
        NullPointerException空指针异常,是一个运行期异常(RuntimeException或者是RuntimeException的子类对象),我们不用处理,默认交给JVM处理
        ArrayIndexOutOfBoundsException数组索引越界异常,是一个运行期异常(RuntimeException或者是RuntimeException的子类对象),我们不用处理,默认交给JVM处理
   */
    public static int getElement (int[] arr,int index){
        /*
            我们可以对传递过来的参数数组arr,进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常,告知方法的调用者,"传递的数组的值是null"
         */
        if(arr == null){
            throw new NullPointerException("传递的数组的值是null");
        }

        /*
            我们可以对传递过来的参数index进行合法性校验
            如果index不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者“传递的索引超出了数组的适用范围”
         */
        if(index < 0 || index > arr.length - 1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的适用范围");
        }
        int ele = arr[index];
        return ele;
    }

    public static void main(String[] args) {
//        int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);
        System.out.println(e);
    }
}

1.3.2 Objects非空判断

还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

requireNonNull是一个泛型方法,传入null值时,会抛出NullPointerException,否则会返回传入的对象。源码如下：

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

1.3.3 异常的第一种处理方式：throws关键字

throws关键字实际上并不是处理了异常，而是进行了一种甩锅行为,它将产生的异常对象抛给方法的调用者处理，如果方法的调用者也没有对异常进行try…catch处理而是也进行了throws抛出,那就继续甩锅，如果一直没有处理一直throws甩锅下去,那么JVM将会背着个锅，从而进行程序中断处理。

throws关键字使用格式：在方法声明时使用

修饰符 返回值类型 方法名(参数列表)throws AAAException,BBBException{
            throw new AAAException("产生原因");
            throw new BBBException("产生原因");
            ...
        }

throws关键字使用注意事项：

throws关键字必须写在方法声明处
throws关键字后边声明的异常必须是Exception或者Exception的子类,但是最好声明详细的子类,以便于如果后面使用try…catch处理可以更加精确
方法内部如果抛出了多个异常对象,throws后面必须也声明多个异常。如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
调用了一个声明抛出异常的方法,我们就必须处理生命的异常要么,继续使用throws声明抛出,把异常交给方法的调用者处理,最终交给JVM中断处理，要么try…catch自己处理异常

代码演示如下：

public class Demo05Throws {
    /*
        FileNotFoundException extends IOException
        IOException extends Exception
        如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
     */
//    public static void main(String[] args) throws FileNotFoundException,IOException {
//    public static void main(String[] args) throws IOException {
    public static void main(String[] args) throws Exception {
        readFile("c:\\a.txt");
        readFile("e:\\a.txt");

        //  如果throws声明抛出,把异常交给方法的调用者处理,最终交给JVM中断处理,那么异常处后面的代码将无法执行
        //  使用try...catch则可以避免此种情况
        System.out.println("后续代码");
    }
    /*
        定义一个方法,对传递的文件路径进行合法性判断
        如果路径不是“c:\\a.txt”,那么我们就抛出文件找不到异常对象,告知方法的调用者
        注意：
            FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
            可以使用throw继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
     */

//    public static void readFile(String fileName) throws FileNotFoundException,IOException {
//    public static void readFile(String fileName) throws IOException {
    public static void readFile(String fileName) throws Exception {
        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }

        /*
            如果传递的路径不是以.txt结尾,
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
         */
        if(fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没问题,继续读取文件");
    }
}

1.3.4 异常的第二种处理方式：try…catch…

try…catch： 异常处理的第二种方式,自己处理异常,注意可以有多个catch
try…catch使用格式：

try{
            可能产生异常的代码
}catch(定义一个异常的变量,用来接收try中抛出的异常对象){
    异常的处理逻辑,产生异常对象之后,怎么处理异常对象
    一般在工作中,会把异常的信息记录到一个日志中
}
 ...
}catch(异常类名 变量名){
}

注意事项：

try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
如果try中产生了异常,那么就会将try中代码产生的异常对象抛给相应的catch处理,执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try…catch之后的代码
如果try中没有产生异常,那么就不会执行catch中的异常处理逻辑,而是执行完try中的代码,继续执行try…catch之后的代码

至于catch里的异常处理逻辑通常会调用异常的终极父类Throwable类里的静态方法进行处理，输出异常信息。

1.3.4.1 Throwable类

Throwable类当中定义了一些方法可以查看输出异常信息。

Throwable类是Exception的父类,而throw关键字产生的异常类型无论是运行期异常还是编译期异常都一定是Exception或Exception的子类,因此这些异常对象都有这三个方法
public String getMessage():返回此 throwable的简短描述
public String toString():返回此 throwable 的详细消息字符串
public void printStackTrace():JVM打印异常对象,默认此方法,打印的异常信息是最全面的。此方法虽然是红字打印的异常信息,但是并没有终止程序的运行,后面的代码依然会运行

代码演示：

public class Demo01TryCatch {
    public static void main(String[] args) {
        try{
            //  可能产生异常的代码
            readFile("d:\\a.tt");
            System.out.println("资源释放"); //  如果上面那行代码产生异常对象,则会跳过该行代码到catch中处理异常,该语句执行不到,此时可采用finally代码块进行解决
        }catch(IOException e){  //  try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
            //  异常的处理逻辑,产生异常对象之后,怎么处理异常对象
            /*System.out.println("catch - 传递的文件后缀不是.txt");*/

            
            System.out.println(e.getMessage()); //  文件的后缀名不对
            System.out.println(e.toString());   //  java.io.IOException: 文件的后缀名不对
            System.out.println(e);  //  java.io.IOException: 文件的后缀名不对
            e.printStackTrace();    //  虽然是红字打印的异常信息,但是并没有终止程序的运行,后面的代码依然会运行
        }

        System.out.println("后续代码");
    }


    /*
        如果传递的路径,不是.txt结尾
        那么我们抛出IO异常对象,告知方法的调用者,文件的后缀名不对
     */
    public static void readFile(String fileName) throws IOException {
        /*
            如果传递的路径不是以.txt结尾,
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没问题,继续读取文件");
    }
}

1.3.4.2 finally代码块

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

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

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

注意:finally不能单独使用。

比如在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

finally代码参考如下：

public class Demo02TryCatchFinally {
    public static void main(String[] args) {
        try {
            //  可能产生异常的代码
            readFile("c:\\a.tt");
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            //  无论是否出现异常,finally代码块中的代码都一定会执行
            System.out.println("资源释放");
        }
    }


    /*
        如果传递的路径,不是.txt结尾
        那么我们抛出IO异常对象,告知方法的调用者,文件的后缀名不对
     */
    public static void readFile(String fileName) throws IOException {
        /*
            如果传递的路径不是以.txt结尾,
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没问题,继续读取文件");
    }
}

注意：

如果finally有return语句,那么将永远返回finally中的结果,要避免该情况
当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

针对第一点注意事项代码演示如下：

public class Demo02Exception {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(a);  //  100
    }
    //  定义一个方法,返回变量a的值
    public static int getA(){
        int a = 10;
        try{
            return a;
        }catch(Exception e){
            System.out.println(e);
        }finally {
            a = 100;
            return a;
        }
    }
}

1.3.4.3 多个异常try…catch的3种处理方式

多个异常使用捕获又该如何处理呢？

多个异常分别处理
多个异常一次捕获,多次处理
多个异常一次捕获,一次处理

注意：
使用一个try,多个catch时，catch里边定义的异常变量,如果有子父类关系,那么子类的异常变量就要写在上面,否则就会报错(因为可能会发生多态赋值,从而会发生短路现象)

代码演示如下：

public class Demo01Exception {
    public static void main(String[] args) {
 
        //  1.多个异常分别处理
        /*try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);  //  ArrayIndexOutOfBoundsException: 3
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }*/
//        System.out.println(arr[3]);

        /*try{
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));    //  IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }*/

//        System.out.println("后续代码执行；");

        //  2.多个异常一次捕获,多次处理
        /*try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]); //  ArrayIndexOutOfBoundsException: 3

            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));    //  IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }*/
//        System.out.println("后续代码执行；");


        /*
            一个try,多个catch注意事项：
                catch里边定义的一场变量,如果有子父类关系,那么子类的异常变量就要写在上面,否则就会报错(因为可能会发生多态赋值,从而会发生短路现象)
         */
        /*try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]); //  ArrayIndexOutOfBoundsException: 3

            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));    //  IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }*/
        //  ArrayIndexOutOfBoundsException继承了IndexOutOfBoundsException,所以ArrayIndexOutOfBoundsException应该在前边


        //  3.多个异常一次捕获,一次处理
        /*try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]); //  ArrayIndexOutOfBoundsException: 3

            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));    //  IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }*/
//        System.out.println("后续代码执行！");

        //  运行时异常被抛出可以不处理。既不捕获也不声明抛出
        //  默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,再来继续执行程序
        int [] arr = {1,2,3};
        System.out.println(arr[3]);
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));

        System.out.println("后续代码执行！");
    }
}

1.3.5 异常在方法重写中的注意事项

子父类的异常：

如果父类抛出了多个异常,子类在重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
如果父类方法没有抛出异常,子类重写父类方法时也不能抛出异常。此时子类产生异常,只能捕获处理(可以使用第二种异常处理方式：try…catch处理),不能声明抛出

代码演示如下：

public class Fu {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() {}
}

class Zi extends Fu{
    //  子类重写父类方法时,抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    //  子类重写父类方法时,抛出父类异常的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //  子类重写父类方法时,不抛出任何异常
    public void show03(){}
    /*
        如果父类方法没有抛出异常,子类重写父类方法时也不能抛出异常。
        此时子类产生异常,只能捕获处理,不能声明抛出
     */
//    public void show04() throws Exception(){}
    public void show04(){
        try{
            throw new Exception("编译期异常");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

1.3.6 自定义异常类

自定义异常类格式如下：

既然是异常,那么就要继承Exception或者继承RuntimeException
puublic class XXXException extends Exception / RuntimeException{
    添加一个空参数的构造方法
    添加一个带异常信息的构造方法(通常是调用父类的带参构造方法)
}

注意：

自定义异常类一般都是以Exception结尾,说明该类是一个异常类
自定义异常类必须要继承Exception或者RuntimeException
继承Exception:那么自定义的类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws抛出,要么try…catch自己处理
继承RuntimeException：那么自定义的类就是一个运行期异常,无需处理,交给虚拟机JVM进行中断处理
查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类异常信息的构造方法,让父类来处理这个异常信息

作业：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
代码如下：

//	定义一个Register异常类
public class RegisterException extends Exception{
    //  添加一个空参数的构造方法
    public RegisterException(){
        super();
    }
    /*
        添加一个带异常信息的构造方法
        查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类异常信息的构造方法,让父类来处理这个异常信息
     */
    public RegisterException(String message){
        super(message);	//	调用父类的带参构造方法
    }
}

//	定义测试类
public class Demo01RegisterException {
    static String[] userNames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //  2.使用Scanner获取用户输入的注册的用户名(前端,界面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名：");
        String userName = sc.next();
        checkUserName(userName);
    }

    //  定义一个方法,对用户输入的注册的用户名进行判断
    public static void checkUserName(String userName) /*throws RegisterException*/ {
        for (int i = 0; i < userNames.length; i++) {
            if(userNames[i].equals(userName)){
                try {
                    throw new RegisterException("亲,该用户名已经被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
//                  在处理编译期异常时,使用throws抛给Java虚拟机处理才会中断程序,而try...catch则不会自动中断程序,而是会在处理完异常以后继续向下执行代码
                    return; //  结束方法
                }
            }
        }
        System.out.println("恭喜您,创建成功");
    }
}

第二章多线程

2.1 并发与并行

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

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意： 单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

一个核只能并发执行多个程序，一定不能并行执行多个程序
多个核可以并行执行多个程序,其中的每一个核实际上依然是只能并发执行多个程序,一个核在多个程序之间来回高速切换执行

2.2 进程和线程

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

简单理解: 进程是指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程资是系统进行资源调度和分配的最小单位。
在这里插入图片描述
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

下列比喻转自知乎biaodianfu
做个简单的比喻：进程=火车，线程=车厢

线程在进程下行进（单纯的车厢无法运行）
一个进程可以包含多个线程（一辆火车可以有多个车厢）
不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）
"互斥锁"进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

线程调度:

分时调度

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

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

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。**对于CPU的一个核而言，某个时刻，只能执行一个线程，**而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。
在这里插入图片描述
主线程

2.3 创建多线程程序的第一种方法—>创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

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

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

void start() 使用该线程开始执行；Java虚拟机调用该线程的run方法。
结果是两个线程并发的运行; 当前线程(main线程)和另一个线程(创建的新线程,执行其run方法)。
多次启动一个线程是非法的。特别是当线程已经结束执行后,不能再重新启动。
Java程序属于抢占式调度,哪线程的优先级高,哪个线程就优先执行;同一个优先级,随机选择一个进行执行

创建单线程程序代码如下：

/*
    主线程：执行主(main)方法的线程

    单线程程序：java程序中只有一个线程
    执行从main方法开始,从上到下依次执行

    JVM执行main方法,main方法会进入到栈内存
    JVM会找操作系统开辟一条main方法通向cpu的执行路径
    cpu就可以通过这条路径来执行main方法
    而这条路径有一个名字,叫main(主)线程
 */
 //	定义Person类
 public class Person {
    private String name;

    public void run(){
        //  定义循环,执行20次
        for(int i = 0;i < 20;i++){
            System.out.println(name + "--->" + i);
        }
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//	定义测试类
public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("泰隆");
        p1.run();
        System.out.println(0/0);    //  ArithmeticException: / by zero
        Person p2 = new Person("艾瑞莉娅");
        p2.run();
    }
}

创建多进程代码程序如下：

//	创建一个Thread类的子类
public class MyThread extends Thread{
	
	//	在Thread类的子类当中重写run方法,定义线程任务
	@Override
	public void run(){
		for(int i = 0;i < 20;i++){
			//	getName()方法会返回当前线程的名称,后面会详细介绍Thread类的几个常用方法
			System.out.println( “小强:” + i);
		}
	}
}


//	定义测试类
public class Demo01Thread {
    public static void main(String[] args) {
        //  3.创建Thread类的子类对象,也就是线程对象
        MyThread mt = new MyThread();
        //  4.调用线程对象的start方法,开启新的线程,执行run方法
        mt.start();

		//	定义主线程任务
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财:" + i);
        }
    }
}

上面代码的执行结果为：

旺财:0
小强:0
旺财:1
小强:1
旺财:2
小强:2
旺财:3
小强:3
旺财:4
小强:4
旺财:5
小强:5
旺财:6
小强:6
旺财:7
小强:7
旺财:8
旺财:9
小强:8
旺财:10
小强:9
旺财:11
小强:10
旺财:12
小强:11
旺财:13
小强:12
旺财:14
小强:13
旺财:15
小强:14
旺财:16
小强:15
旺财:17
小强:16
旺财:18
小强:17
旺财:19
小强:18
小强:19

2.4 多线程运行原理

在这里插入图片描述

2.5 多线程内存图

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。
通过这张图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？我们再来讲一讲原理。多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明：
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。在调用strat方法进行开辟多线程时,同时也开辟了一块儿新的线程空间(栈空间)进行方法的压栈和弹栈。
在这里插入图片描述

2.6 Thread类常用方法与构造方法

常用方法
public String getName():获取当前线程名称
public void start():开启此线程；Java虚拟机调用此线程的run方法
public void run():此线程要执行的任务在此处定义代码
public static void sleep(long millis):使当前正在执行的额线程,以指定的毫秒数暂停(暂时停止执行)
public static Thread currentThread():返回当前正在执行的线程对象的引用

注意后面两个sleep和currentThread是静态方法,通过Thread类名直接调用

线程的名称：

主线程：main
新线程：Thread-0;Thread-1;Thread-2

2.6.1 获取线程名称的两种方式

获取线程名称的两种方式：

使用Thread类中的方法getName()
String getName() 返回该线程的名称
可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回对当前正在执行的线程对象的调用

使用Thread类中的方法获取线程名称

//	定义一个Thread类的子类
public class MyThread extends Thread{
	@Override
	public void run(){
		//	获取线程名称
		String name = getName();
        System.out.println("子线程名称：" + name);		
	}
}

//	定义测试类
public class Demo01GetThreadName {
    public static void main(String[] args) {
    	MyThread mt = new MyThread();
    	mt.start();

		System.out.println("main方法下线程名：" + Thread.currentThread().getName());
    }
}  


程序运行结果为：
main方法下线程名：main
子线程名称：Thread-0

使用Thread类中的currentThread()方法获取到正在运行的线程引用,然后调用其getName()方法获得线程名称(注意下面代码中链式编程的写法)

//	定义Thread类的子类
public class MyThread extends Thread{
    //  重写Thread类中的run方法

    @Override
    public void run() {
        //  获取线程的名称
        /*String name = getName();
        System.out.println("子线程名称：" + name);*/

        /*Thread t = Thread.currentThread();
        System.out.println(t);  //  Thread[Thread-0,5,main]
        String name = t.getName();
        System.out.println(name);*/

        //  链式编程
        System.out.println("子线程名称:" + Thread.currentThread().getName());
    }
}



//	定义测试类
public class Demo01GetThreadName {
    public static void main(String[] args) {
        //  创建Thread类的子类对象
        MyThread mt = new MyThread();
        //  调用start方法,开启新线程
        mt.start();
//        System.out.println("main方法下线程名：" + Thread.currentThread().getName());

        new MyThread().start();
        new MyThread().start();

        //  链式编程
        System.out.println("main方法下线程名：" + Thread.currentThread().getName() );
    }
}



//	程序运行结果
子线程名称：Thread-2
main方法下线程名：main
子线程名称：Thread-1
子线程名称：Thread-0

2.6.2 设置线程名称的两种方式(了解)

*设置线程的名称(了解)

使用Thread类中的方法setName(名字)
void setName(String name) 改变线程名称,使之与参数name相同
创建一个带参数的构造方法,参数传递线程的名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
Thread(String name)分配新的 Thread 对象

代码演示如下：

//	定义Thread子类
public class MyThread extends Thread{
    public MyThread(){}

    public MyThread(String name){
        super(name);    //  调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }

    @Override
    public void run() {
        //  获取线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}


//	定义测试类
public class Demo01SetThreadName {
    public static void main(String[] args) {
        //  开启多线程
        MyThread mt = new MyThread();
        mt.setName("小强");
        mt.start();

        //  开启多线程
        new MyThread("旺财").start();
    }
}

2.6.3 sleep方法

注意这是个静态方法,通过Thread.sleep(long millis)直接调用

public class Demo01Sleep {
    public static void main(String[] args) {
        //  模拟秒表
        for(int i = 1; i <= 60;i++){
            System.out.println(i);

            //  使用Thread类的sleep方法让程序睡眠一秒钟
            try {
                Thread.sleep(1000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.6.4 Thread类的构造方法

Thread类有以下四个构造方法:
public Thread():分配一个新的线程对象
public Thread(String name):分配一个指定名字的线程对象
public Thread(Runnable target):分配一个带有指定目标的新的线程对象
public Thread(Runnable target,String name):分配一个带有指定目标的新的线程对象,并指定名字

2.6.5 创建多线程程序的第二种方式【重点】

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法,设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象,构造方法中传入Runnable接口的实现类对象
5.对Thread类对象调用Thread类中的start方法,开启新的线程执行run方法

代码演示如下：

//	定义Runnable接口的实现类
public class RunnnableImpl implements Runnable{
	//	重写Runnable接口中的run方法
	@Override
	public void run(){
		for (int i = 0; i < 20; i++) {
            System.out.println("Hello World!");
        }
	}
}


//	定义测试类
public class Demo01Runnable {
    public static void main(String[] args) {
    	//	创建一个Runnable接口的实现类对象
    	RunnableImpl run = new Runnable();
    	//	创建Thread类对象
    	Thread t = new Thread(run);
    	t.stratt();

		for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnabletarget)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

注意：
Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。当创建多个Thread对象却传入相同的Runnable实例对象时,就可以访问处理到相同的资源，当然这也会引发一定的安全问题，比如同时修改共同资源就会引发问题

2.6.6 使用匿名内部类方式实现线程的创建

代码演示如下：

public class Demo01InnerClassThread {
    public static void main(String[] args) {
    	new Thread(new Runnable(){
			@Override
			public void run(){
				for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread() + "--->" + "卡兹克");
                }
			}
		}).start();
    }
}

2.7 Thread子类和Runnable两种创建多线程的区别【重点】

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
实现Runnable接口比继承Thread类所具有的优势：

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

通过继承Thread类实现多线程：
优点：
实现起来简单，而且要获取当前线程，无需调用Thread.currentThread()方法，直接使用this即可获取当前线程；
缺点：
1、线程类已经继承Thread类了，就不能再继承其他类；
2、多个线程不能共享同一份资源;

通过实现Runnable接口或者Callable接口实现多线程：
优点：
1、线程类只是实现了接口，还可以继承其他类；
2、多个线程可以使用同一个target对象，适合多个线程处理同一份资源的情况。
缺点：
1、通过这种方式实现多线程，相较于第一类方式，编程较复杂；
2、要访问当前线程，必须调用Thread.currentThread()方法。

The_______shy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习第十七天

Java学习第十七天第一章异常1.1 异常概述1.2 异常产生过程的解析1.3 异常的处理第一章异常1.1 异常概述异常的定义：指的是程序在执行过程，出现的非正常的情况，最终会导致JVM的非正常停止。在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。异常体系：异常机制其实是帮助我们找到程序中的问题,异常的根类是java.lang.Throwable,该类下面有两个子类java.lang.Error和java
复制链接

扫一扫