尚硅谷|异常处理&多线程

已于 2024-03-08 19:19:35 修改
阅读量670 收藏 20
点赞数 9
文章标签： java 开发语言
于 2024-02-23 22:42:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73795426/article/details/136248316
版权

异常处理

体系结构

throwable:异常体系根父类

        --》：Error错误，不编写代码处理

               stackOverflowError,OutOfMemoryError

        --》：Exception异常，可以编写代码处理

                --》编译时异常（受检异常）

                ClassNotFoundException

                FileNotFoundException

                 IOEception

                --》运行时异常（非受检异常）

public class ExceptionTest {
    @Test
    public void test1(){
        int[] arr = new int[10];
        System.out.println(arr[10]);
    }
    @Test
    public void test2(){
        int[][] arr=new int[2][];
        System.out.println(arr[1][1]);
    }
    @Test
    public void test3(){
        Object obj = new String();
        Date date=(Date) obj;
    }
    @Test
    public void test4(){
        String str="123";
        str="abc";
        int i = Integer.parseInt(str);
    }
    @Test
    public void test5(){
        Scanner scan=new Scanner(System.in);
        int num=scan.nextInt();
        System.out.println(num);//用户输入abc并非整形数字会报异常，输入不匹配
    }
    @Test
    public void test6(){
        int num = 10;
        System.out.println(num/0);//算术异常
    }
}

异常处理

方式一：try-catch-finally

try-catch

声明多个catch结构，父类应声明在最下面

处理：public void printStackTrace()打印异常的详细信息

           public String getMessage()获取发生异常的原因

try中声明的变量出了try结构之后不可以再调用

实际开发时运行时异常通常不进行处理

编译时异常一定要处理否则不通过：ClassNotFoundException，FileNotFoundException，IOException

finally使用

finally中的代码一定会被执行

有些资源必须要手动关闭，比如输入流，输出流，数据库连接。这部分代码必须放到finally中

方式二：throws+异常类型

子类重写方法抛出的异常类型可以与父类相同或是父类异常的子类

比如这种情况：运行时调用子类的method方法，抛出的异常Exception catch无法捕获（与多态自洽）

public class ThrowsTest {
    public static void main(String[] args) {
        Father f1= new Son();
        try{
            f1.method();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
class Father{
    public void method()throws IOException{
        
    }
}
class Son extends Father{
    public void method()throws Exception{

    }
}

如何选择两种方式

>>try-catch-finally:资源一定要被执行，重写(父类无throws,子类只能trycatch）

>>a依次调用b,c,d方法,b\c\d之间递进，此时b\c\d有异常选择throws，而在a中使用try-catch-finally

手动抛出

需求

实际开发中出现不满足具体场景的问题，手动抛出异常

public class ThrowTest {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.register(-10);
        System.out.println(stu);
    }
}
class Student{
    int id;
    public void register(int id){
        if(id > 0){
            this.id=id;
        }else{
            throw new RuntimeException("输入id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

自定义异常

需求：通过异常名称直接判别异常原因，因此自定义

通常继承于现有的异常体系RuntimeException\Exception

public class BelowZeroException extends Exception{
    static final long serialVersionUID = -6255851812010695214L;

    public BelowZeroException() {
    }

    public BelowZeroException(String message) {
        super(message);
    }

    public BelowZeroException(String message, Throwable cause) {
        super(message, cause);
    }
}

项目笔记

下面这段代码有什么问题呢？尚未解决。。。。。

        if (p instanceof Architect) {
            if (arcNum >= 1)
                throw new TeamException("团队中只能有一名架构师");
        } else if (p instanceof Designer) {
            if (desNum >= 2)
                throw new TeamException("团队中只能有两名设计师");
        } else {
            if (progNum >= 3)
                throw new TeamException("团队中只能有三名设计师");
        }

      /*  if (p instanceof Architect && arcNum >= 1) {
            throw new TeamException("团队中只能有一名架构师");
        } else if (p instanceof Designer && desNum >= 2) {
            throw new TeamException("团队中只能有两名设计师");
        } else if (p instanceof Programmer && progNum >= 3) {
            throw new TeamException("团队中只能有三名设计师");
        }*/

多线程

相关概念理解

进程，线程

线程隔离区：虚拟机栈，本地方法栈，程序计数器

线程共享区：方法区，堆

线程调度：分时调度，抢占式调度

单核/多核

并行：多个事件在同一时刻发生

并发：多个事件在同一时间段内发生。即在同一时间段内，多条指令在单个CPU上快速轮换，交替进行，宏观上看起来是多个事件同时进行

创建和启动线程

    Thread thread = new Thread(()->{
            System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().isDaemon());
            while (true){

            }
        },"aa");

实例化线程对象通过构造方法命名。

Java线程的三种命名方法 - 戈德里克山谷 - 博客园 (cnblogs.com)

方式1

创建线程匿名子类

public class DoubleThreadTest {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for(int i=1;i<=100;i++){
                    if(i%2==1)
                        System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for(int i=1;i<=100;i++){
                    if(i%2==0)
                        System.out.println(Thread.currentThread().getName()+":"+ i);
                }
            }
        }.start();
    }
}

方式2

public class EvenNumberTest {
    public static void main(String[] args) {
        PrintNumber printNumber = new PrintNumber();
        Thread t1=new Thread(printNumber);
        t1.start();
    }
}

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

提供Runnable接口匿名实现类的匿名对象

public class DoubleThreadTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<100;i++){
                    if(i%2==1)
                        System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=1;i<100;i++){
                    if(i%2==0)
                        System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }).start();
    }
}

Runnable适合共享数据处理，避免类的单继承性，实现代码和数据分类

Thread常用方法

构造器

常用方法

join()：在线程a中通过线程b调用join()，意味着线程a进入阻塞状态，知道线程b执行结束，线程a才结束阻塞状态，继续执行。

yield()静态方法，一旦执行此方法，释放CPU的执行权

isAlive：判断是否存活

sleep()：静态

线程优先级

默认优先级是5，设置范围是【1，10】，ctrl+F12查看

声明周期

JDK5之前：

JDK5之后

线程安全

同步监视器（锁）：可以用任何一个类的对象充当，但是多个线程必须共用同一个锁

同步代码块

接口方式

同步监视器可以用this充当，只造了一个对象

public class WinTest {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        Thread t1=new Thread(ticket);
        Thread t2=new Thread(ticket);
        Thread t3=new Thread(ticket);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Ticket implements Runnable {
    @Override
    public void run() {
        synchronized (this){
            int ticket = 100;
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

继承方式

锁改成(类名.class),反射会讲

public class WindowTest {
    public static void main(String[] args) {
        SaleTicket s1=new SaleTicket();
        s1.setName("窗口1");
        SaleTicket s2=new SaleTicket();
        s2.setName("窗口2");
        SaleTicket s3=new SaleTicket();
        s3.setName("窗口3");
        s1.start();
        s2.start();
        s3.start();
    }
}

class SaleTicket extends Thread {
    static int ticket = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (SaleTicket.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

同步方法

操作共享数据的代码完整的声明在方法中，则将此方法声明为同步方法

synchronized修饰非静态方法，锁默认是this，比较适合修饰实现Runnabl接口类的方法。

synchronized修饰静态方法，锁默认是当前类。

线程安全懒汉式

方式1：

class Bank{
    private Bank(){}
    private static Bank instance=null;
    public static synchronized Bank getInstance(){//类只加载一次，同步监视器，默认为Bank.class
        if(instance==null){
            instance=new Bank();
        }
        return instance;
    }
}

方式2：同步代码块

class Bank{
    private Bank(){}
    private static Bank instance=null;
    public static Bank getInstance(){
        if(instance==null){
            synchronized (Bank.class) {
                if(instance==null){
                    instance=new Bank();
                }
            }
        }
        return instance;
    }
}

死锁

lock

1.确保多个线程共用同一个lock实例(考虑声明为 static )

2.执行lock方法

3.unlock

public class WindowTest {
    public static void main(String[] args) {
        SaleTicket s1=new SaleTicket();
        s1.setName("窗口1");
        SaleTicket s2=new SaleTicket();
        s2.setName("窗口2");
        SaleTicket s3=new SaleTicket();
        s3.setName("窗口3");
        s1.start();
        s2.start();
        s3.start();
    }
}

class SaleTicket extends Thread {
    static int ticket = 100;
    private static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

线程间通信机制

案例：交替打印

public class PrintNumberTest {
    public static void main(String[] args) {
        PrintNumber p=new PrintNumber();
        Thread t1=new Thread(p,"线程1");
        Thread t2=new Thread(p,"线程2");
        t1.start();
        t2.start();
    }
}
class PrintNumber implements Runnable{
    int number =1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                notify();
                if(number<=100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":"+number);
                    number++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

wait()，notify()，nitifyAll()的使用必须在同步代码块或同步方法中，并且方法的调用者必须是同步监视器。

消费者生产者案例

全国吃麻辣烫比赛第一名
关注
尚硅谷Java入门视频教程第八章——多线程
yw_1121的博客
05-08 351
尚硅谷Java入门视频教程第八章——多线程
bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第一章——线程基础知识复习
qq_46601365的博客
02-21 1145
如果用户线程全部结束意味着程序需要完成的业务操作已经结束了，守护线程随着JVM一同结束工作。
Java多线程的详细介绍
weixin_45661472的博客
03-27 768
多线程的详细介绍 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线.
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 1660
文章标题
尚硅谷_Java零基础教程（多线程）-- 学习笔记
JMW1407的博客
08-26 584
Java 多线程一、基本概念1、程序、进程、线程2、单核CPU和多核CPU、并行与并发3、使用多线程的优点二、线程的创建和使用1、API中创建线程的两种方式1.1、方式一： 继承Thread类1.2、方式二：实现Runnable接口1.3、Thread类的调用的API方法2、线程的调度3、线程的优先级三、线程的生命周期四、线程的同步1、同步方法1.1、Synchronized的使用方法五、线程的通信六、JDK5.0新增线程创建方式 一、基本概念 1、程序、进程、线程 程序(program)：是为完成特定任
尚硅谷java基础学习笔记day17
weixin_43808506的博客
08-11 323
尚硅谷java基础学习笔记 day17 com.dg.java package com.dg.java; /** * 多线程的创建，方式一：继承于Thread类 * 1. 创建一个继承于Thread类的子类 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中 * 3. 创建Thread类的子类的对象 * 4. 通过此对象调用start() * <p> * 例子：遍历100以内的所有的偶数 * * @author shkstart *
尚硅谷2015C++全套视频
02-26
该视频教程可能涵盖了C++的基础概念、语法特性、面向对象编程、模板、STL（Standard Template Library）以及高级主题，如多线程、异常处理和C++11/14/17新特性。 1. **C++基础**：学习C++首先从基础语法开始，包括...
尚硅谷全套视频
09-05
4. 多线程：掌握并发编程，了解线程池、同步机制。 5. Spring框架：学习Spring Boot、Spring MVC，实现企业级应用开发。 6. 数据库：MySQL基础操作，JDBC连接，以及ORM框架如Hibernate、MyBatis的应用。 三、大数据...
Java 基础 第3阶段：高级应用-尚硅谷学习笔记（含面试题） 2023年
05-09
在Java的高级应用领域，开发者通常需要掌握一系列深入的技术和概念，这些内容涵盖了多线程、集合框架、网络编程、反射、I/O流、异常处理、设计模式等多个方面。在这个阶段的学习中，尚硅谷提供了2023年的学习笔记和...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 316
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 570
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1090
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 586
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 885
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 322
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1148
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1044
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
尚硅谷全集：Java & Android 视频教程
- **尚硅谷Java基础实战——Bank项目**：通过实际项目练习，加深对Java编程的理解，涉及类、对象、接口、多线程等。 - **ORACLE、SQL、PLSQL**：讲解数据库基础，包括SQL查询语句和Oracle数据库的使用。 - **JDBC...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值