异常,多线程

1 异常的概述

1.1 什么是异常?

异常就是程序出现了不正常情况 , 程序在执行过程中 , 数据导致程序不正常 , 最终导致了JVM的非正常停止
注意 : 语句错误不算在异常体系中

1.2 异常的存在的形式

异常有类型之分，比如我们之前有接触过的比较熟悉的数组越界异常（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException），类型转换异常（ClassCastException）。当程序中产生异常时，其实就是在异常的位置创建了一个该异常的对象，该对象携带了相关的异常信息。
- 简单来说 : 异常就是Java中提供的类的对象

1.3 程序中异常产生后，是如何处理的

程序中一旦产生异常，首先会中断向下执行。异常的传递要根据处理方式（后面章节会讲到）而定，如果没有处理，默认是将异常传递给本方法的调用者。不断往回传递，直到JVM收到该异常，此时程序终止执行

2 异常的分类

编译时期异常
- 非RuntimeException及其子类 : 编译时异常就是在编译的时候可能出现的异常, 编译时期必须处理,否则程序无法执行
运行时期异常
- RuntimeException及其子类 : 运行时异常就是在运行时可能出现的异常, 在编译时期不需要处理

3 异常的处理方式

3.1 JVM处理异常的方式

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理 , 那么JVM是如何处理的呢 ?
- 把异常的类型 , 原因 , 位置打印在控制台
- 程序停止执行
注意 : 程序中出现了异常 , 会在当前位置创建此异常的对象 , 对象中包含了异常的信息 , 并把此异常交给本方法的调用者处理
缺点 : 用户体验不好

3.2 手动处理异常方式

3.2.1 声明异常

声明异常—— throws
- 修饰符返回值类型方法名(参数列表) throws 异常类型1 , 异常的类型2...
- 举例 : public void show() throws NullPointerException , ArrayIndexOutOfBoundsException
作用 :
- 表示调用当前的方法可能会出现某些异常,使用时需要注意哦!
- 如果当前方法没有出现任何异常, 那么代码会正常执行
- 如果当前方法中出现了异常 , 会把异常交给本方法调用者处理(甩锅)

java

package com.fan.exception_demo;

import sun.java2d.pipe.SpanShapeRenderer;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    声明异常—— throws
        格式 : 修饰符   返回值类型  方法名(参数列表) throws 异常类型1 , 异常的类型2...   {  ...  }
        举例 : public void show() throws NullPointerException , ArrayIndexOutOfBoundsException  { .... }
        作用 :
            1 表示告知调用者当前的方法可能会出现某些异常,使用时需要注意哦!
            2 如果当前方法没有出现任何异常, 那么代码会正常执行
            3 如果当前方法中出现了异常 , 会把异常交给本方法调用者处理(甩锅)

    需求 :
        练习 : 定义两个方法一个运行时期异常 , 一个声明编译时期异常 !

    注意 :
        1 编译时异常因为在编译时就会检查，所以必须要写在方法后面进行显示声明
        2 运行时异常因为在运行时才会发生，所以在方法后面可以不写
        3 如果声明多个异常有子父类关系 , 那么只要声明一个父类即可(多态)
 */
public class Exception_Throws {
    public static void main(String[] args) throws ParseException{
        printArr();// 如果此方法出现了异常 , 会交给jvm进行处理
        StringToDate();// 如果此方法出现了异常 , 会交给jvm进行处理
    }

    // 1 告诉调用者 , 此方法可能会出现异常哦
    // 2 如果此方法没有出现异常 , 那么会正常执行
    // 3 如果此方法中出现了异常 , 会把此异常交给调用者处理
    // 注意 : 如果声明的异常是一个运行时期异常 , 那么此声明可以省略
    public static void printArr() /*throws NullPointerException*/ {
        int[] arr = null;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    // 1 告诉调用者 , 此方法可能会出现异常哦
    // 2 如果此方法没有出现异常 , 那么会正常执行
    // 3 如果此方法中出现了异常 , 会把此异常交给调用者处理
    // 注意 : 如果声明的异常 是一个编译时期异常 , 那么在编译时期必须处理 , 要么程序无法执行
    public static void StringToDate() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse("2000-03-11 12:12:12");
    }
}

3.2.2 抛出异常

思考：
- 以前出现了异常，虚拟机帮我们创建一个异常对象，抛给调用者。但是如果我们需要自己手动创建一个异常对象该如何写？

格式 :

java

修饰符    返回值类型    方法名(参数列表)  {
    throw new 异常对象();
}

注意 :
- 抛出异常的格式必须在方法的内部完成
- 如果手动抛出一个异常，下面的代码无法执行

java

package com.fan.exception_demo;

/*
    抛出异常演示 :
        格式 :
            修饰符  返回值类型  方法名(参数列表)  {
                throw new 异常对象();
            }

        注意 :
            1 抛出异常的格式必须在方法的内部完成
            2 如果手动抛出一个异常，下面的代码无法执行
 */
public class Exception_Throw {
    public static void main(String[] args) {
        System.out.println("家里有一个貌美如花的老婆");
        System.out.println("还有一个当官的兄弟");
        System.out.println("自己还有一个买卖");
        System.out.println("这样的生活你要不要?");

        // 程序不想往下执行了 ,怎么做 ???
        // 1 自己手动制造出一个异常
        // 2 当前异常也是交给了方法的调用者处理 , 也就是jvm处理
        // 3 下面代码无法执行
        throw new RuntimeException();

        // System.out.println("武大郎的标准生活!");
    }
}

作用 :

在方法中，当传递的参数有误，没有继续运行下去的意义了，则采取抛出处理，表示让该方法结束运行。
告诉调用者方法中出现的问题原因

java

package com.fan.exception_demo;

/*
    抛出异常存在的意义所在 :
        1 在方法中，当传递的参数有误，没有继续运行下去的意义了，则采取抛出处理，表示让该方法结束运行。
        2 告诉调用者方法中出现了问题

    练习   : 定义一个方法 , 方法的参数接收一个数组 , 在方法中遍历数组 .
    需求1  : 如果方法接收的数组为null  , 使用输出语句提示
    需求2  : 如果方法接收的数组为null  , 使用抛出异常解决
    思考   : 两种方式的区别在哪里 ?
 */
public class Exception_Throw2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        arr = null;
        // printArr1(arr);
        printArr2(arr);// 接收方法返回的异常 , 但是此异常有jvm进行处理
    }

    // 需求1  : 如果方法接收的数组为null  , 使用输出语句提示
    public static void printArr1(int[] arr) {
        if (arr == null) {
            System.out.println("数组为null");
        } else {
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    }

    // 需求2  : 如果方法接收的数组为null  , 使用抛出异常解决
    public static void printArr2(int[] arr) {
        if (arr == null) {
            throw new RuntimeException();
        } else {
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    }
}

3.2.3 throws和throw的区别

throws :
- 用在方法声明后面，跟的是异常类名
- 表示声明异常，告知调用者调用该方法有可能会出现这样的异常
throw :
- 用在方法体内，跟的是异常对象名
- 表示手动抛出异常对象，告知调用者数据传入有误

3.2.4 捕获异常

捕获处理异常介绍 : try, catch，finally
- 之前的声明或者抛出都是将异常传递出去,让调用者知道异常信息。而捕获处理是本方法内部进行处理 , 能够阻止异常的传递，从而保证程序能够继续往下执行。

捕获异常的格式

java

try {
    try中存放可能会出现问题的代码
        1.代码...
        2.代码...
        3.代码...
} catch (异常类型 变量名) {
    	4.处理异常方案
       打印异常，获取异常原因记录日志......）
} finally {
    正常和报错都会执行
}
5.其他代码...

执行方式
- 如果 try 中没有遇到问题，怎么执行？
  - 从上往下依次执行 , catch中不执行
- 如果 try 中代码2遇到了问题，问题下面的代码还会执行吗？
  - 不会执行,会拿当前异常对象和异常类型匹配,匹配成功执行处理异常代码
- 如果出现的问题没有被捕获，那么程序如何运行？
  - 如果异常没有捕获到 , 虚拟机会帮助我们处理

多异常捕获处理方案

多个异常，每个异常单独处理

java

try{
    异常1
}catch(异常1){

} 
try{
    异常2
}catch(异常2){

}

多个异常，一次捕获，多次处理

java

try{
    异常1
    异常2
}catch(异常1){
}catch(异常2){
}

多个异常，异常一次捕获，一次处理

java

try{
    异常1
    异常2
}catch(Exception e){
}

3.3 打印异常信息的三个方法

Throwable 的成员方法

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

3.4 异常练习

java

package com.fan.exception_demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
    定义一个方法接收一个生日日期字符串(xxxx年xx月xx)
    main方法中让用户输入一个生日日期字符串，调用设计好的方法计算在地球上活了多少天。

    要求：如果解析发生异常，捕获异常，提示用户要重新输入生日日期字符串，直到输入正确的日期为止。
    思考：设计代此码的过程中想想什么时候捕获异常，什么时候声明异常？

 */
public class ExceptionTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入生日(xxxx-xx-xx):");
        
        while (true) {
            String birthday = sc.nextLine();
            try {
                method(birthday);
                break;// 如果生日没有问题结束死循环
            } catch (ParseException e) {
                System.out.println("录入生日格式有误!");
            }
        }
    }

    public static void method(String strDate) throws ParseException {
        // 创建日期模板对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        // 解析字符串
        Date date = sdf.parse(strDate);

        // 获取生日到1970/1/1 经历的毫秒值
        long time1 = date.getTime();

        // 当前系统时间到1970/1/1 经历的毫秒值
        Date d2 = new Date();
        long time2 = d2.getTime();


        System.out.println("活了" + (time2 - time1) / (1000L * 60 * 60 * 24) + "天");
    }
}

4 自定义异常

4.1 概述

当JDK中的异常类型，不满足实际的业务需要时。就可以自己定义异常。例如，学生的年龄数据，如果是负数或者数据超过了150认为是不合法的，就需要抛出异常。JDK中就没有表示年龄的异常，就需要自己定义异常了

4.2 实现步骤

定义异常类
写继承关系
空参构造
带参构造

4.3 自定义异常注意

如果要自定义编译时异常，就继承Exception
如果要自定义运行时异常，就继承RuntimeException

案例：

java

1.需求:键盘录入一个用户名,实现登录功能,如果登录失败,抛出LoginUserException

java

public class Demo11Exception {
    public static void main(String[] args) throws LoginUserException {
        //1.创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请您输入要登录的用户名:");
        String username = scanner.next();
        //2.定义一个字符串,代表已经注册过的用户名
        String name = "root";

        //3.判断
        if (username.equals(name)){
            System.out.println("登录成功");
        }else{
            //如果失败了,就创建异常对象
            throw new LoginUserException("登录失败");
        }
    }
}

java

public class LoginUserException extends Exception /*RuntimeException*/{
    public LoginUserException() {
    }

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

1.创建一个类
a.继承Exception,此时变成了编译时期异常
b.继承RuntimeException,此时变成了运行时期异常
2.提供构造方法,方便我们设置异常信息

5 多线程入门

5.1 多线程相关的概念

并发与并行
- 并行：在同一时刻，有多个任务在多个CPU上同时执行。
- 并发：在同一时刻，有多个任务在单个CPU上交替执行。
进程与线程
- 进程：就是操作系统中正在运行的一个应用程序。
- 线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。

5.2 什么是多线程

是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。
好处 : 提高任务的执行性能

5.3 多线程的创建方式

5.3.1 继承Thread方式

基本步骤：

创建一个类继承Thread类。
在类中重写run方法（线程执行的任务放在这里）
创建线程对象，调用线程的start方法开启线程。
执行程序，观察控制台的打印数据的现象

java

package com.fan.thread_demo;

/*
    线程的创建方式1：继承Thread方式

    基本步骤 :
        1 创建一个类继承Thread类。
        2 在类中重写run方法（线程执行的任务放在这里）
        3 创建线程对象，调用线程的start方法开启线程。

    需求 :
        我们启动一个Java程序，其实默认就存在一个主线程（main方法所在线程）
        接下来，我们在主线程启动一个线程，打印1到100的数字，主线程启动完线程后又打印1到100的数字。
        此时主线程和启动的线程在并发执行，观察控制台打印的结果。
 */
public class MyThread01 {
    public static void main(String[] args) {
        // 创建线程对象，调用线程的start方法开启线程。
        MyThread mt = new MyThread();
        mt.start();

        // main方法中的任务
        for (int i = 1; i <= 100; i++) {
            System.out.println("i:" + i);
        }
    }
}
// 创建一个类继承Thread类。
class MyThread extends Thread {
    // 在类中重写run方法（线程执行的任务放在这里）
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("i:" + i);
        }
    }
}

5.3.2 实现Runable方式

构造方法
- public Thread(Runnable target)
- public Thread(Runnalbe target , String name)

实现步骤

定义任务类实现Runnable，并重写run方法
创建任务对象
使用含有Runnable参数的构造方法，创建线程对象并指定任务。
调用线程的start方法，开启线程

java

package com.fan.thread_demo;

/*
     线程的创建方式2：实现Runnable方式

    基本步骤 :
        1 定义任务类实现Runnable，并重写run方法
        2 创建任务对象
        3 使用含有Runnable参数的构造方法，创建线程对象并指定任务。
        4 调用线程的start方法，开启线程

    需求 :
        我们启动一个Java程序，其实默认就存在一个主线程（main方法所在线程）
        接下来，我们在主线程启动一个线程，打印1到100的数字，主线程启动完线程后又打印1到100的数字。
        此时主线程和启动的线程在并发执行，观察控制台打印的结果。
 */
public class MyThread02 {
    public static void main(String[] args) {
        // 创建线程对象，调用线程的start方法开启线程。
        MyRunnable mr = new MyRunnable();
        Thread thread= new Thread(mr);
        thread.start();

        // main方法中的任务
        for (int i = 1; i <= 100; i++) {
            System.out.println("i:" + i);
        }
    }

}

// 1 定义任务类实现Runnable，并重写run方法
class MyRunnable implements Runnable {
    // 在类中重写run方法（线程执行的任务放在这里）
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("i:" + i);
        }
    }
}

5.3.3 Thread类中常用方法

String getName()：返回此线程的名称
Thread类中设置线程的名字
- void setName(String name)：将此线程的名称更改为等于参数 name
- 通过构造方法也可以设置线程名称
public static Thread currentThread()：返回对当前正在执行的线程对象的引用
public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒

线程有两种调度模型

分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程
获取的 CPU 时间片相对多一些

java

package com.fan.thread_demo.thread_method;

/*
    线程有两种调度模型
        1 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
        2 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程
           获取的 CPU 时间片相对多一些

        注意 : Java使用的是抢占式调度模型


        优先级高 , 只是抢夺到cpu执行的概率高而已 , 只是一种概率问题
 */
public class PriorityDemo {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        });
        // 优先级最低
        thread1.setPriority(1);
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        });
        // 优先级最高
        thread2.setPriority(10);
        thread2.start();
    }
}

6 线程安全

6.1 线程安全产生的原因

多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

java

package com.fan.ticket_demo;

/*
    电影院
 */
public class Ticket implements Runnable {
    private int ticketCount = 100; // 一共有一百张票

    @Override
    public void run() {
        while (true) {
            // 如果票的数量为0 , 那么停止买票
            if (ticketCount == 0) {
                break;
            } else {
                // 有剩余的票 , 开始卖票
                ticketCount--;
                System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
            }
        }
    }
}

java

package com.fan.ticket_demo;

/*
    1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    2 在Ticket类中重写run()方法实现卖票，代码步骤如下
        A：判断票数大于0，就卖票，并告知是哪个窗口卖的
        B：票数要减1
        C：卖光之后，线程停止
    3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
        A：创建Ticket类的对象
        B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
        C：启动线程

 */
public class TicketDemo {
    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();
    }
}

注意 : 以上代码是有问题 , 接下来继续改进

因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码

java

package com.fan.ticket_demo;

/*
    电影院
 */
public class Ticket implements Runnable {
    private int ticketCount = 100; // 一共有一百张票

    @Override
    public void run() {
        while (true) {
            // 如果票的数量为0 , 那么停止买票
            if (ticketCount <= 0) {
                break;
            } else {

                // 模拟出票的时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // 有剩余的票 , 开始卖票
                ticketCount--;
                System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
            }
        }
    }
}

java

package com.fan.ticket_demo;

/*
    1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    2 在Ticket类中重写run()方法实现卖票，代码步骤如下
        A：判断票数大于0，就卖票，并告知是哪个窗口卖的
        B：票数要减1
        C：卖光之后，线程停止
    3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
        A：创建Ticket类的对象
        B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
        C：启动线程

 */
public class TicketDemo {
    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();
    }
}

通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题
- 问题出现的原因 : 多个线程在对共享数据进行读改写的时候，可能导致的数据错乱就是线程的安全问题了

6.2 线程的同步 synchronized

概述 : java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证该变量的唯一性和准确性
分类
- 同步代码块
- 同步方法
- 锁机制。Lock

6.3 同步代码块

同步代码块 : 锁住多条语句操作共享数据，可以使用同步代码块实现

第一部分 : 格式
           synchronized(任意对象) {
                   多条语句操作共享数据的代码
           }

第二部分 : 注意
           1 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭
           2 当线程执行完出来了，锁才会自动打开

第三部分 : 同步的好处和弊端
            好处 : 解决了多线程的数据安全问题
            弊端 : 当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

java

public class Ticket implements Runnable {
    private int ticketCount = 100; // 一共有一百张票

    @Override
    public void run() {
        while (true) {
            synchronized (Ticket.class) {
                // 如果票的数量为0 , 那么停止买票
                if (ticketCount <= 0) {
                    break;
                } else {
                    // 模拟出票的时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 有剩余的票 , 开始卖票
                    ticketCount--;
                    System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
                }
            }
        }
    }
}

java

package com.fan.synchronized_demo1;

/*
    1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    2 在Ticket类中重写run()方法实现卖票，代码步骤如下
        A：判断票数大于0，就卖票，并告知是哪个窗口卖的
        B：票数要减1
        C：卖光之后，线程停止
    3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
        A：创建Ticket类的对象
        B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
        C：启动线程

 */
public class TicketDemo {
    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();
    }
}

6.4 同步方法

同步方法：就是把synchronized关键字加到方法上

格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }

同步代码块和同步方法的区别:
    1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
    2 同步代码块可以指定锁对象,同步方法不能指定锁对象

注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
    1 对于非static方法,同步锁就是this。
    2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象

java

package com.fan.synchronized_demo2;

/*
    同步方法：就是把synchronized关键字加到方法上

    格式：修饰符 synchronized 返回值类型 方法名(方法参数) {    }

    同步代码块和同步方法的区别:
        1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
        2 同步代码块可以指定锁对象,同步方法不能指定锁对象

    注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
        1 对于非static方法,同步锁就是this。
        2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。   Class类型的对象

 */
public class Ticket implements Runnable {
    private int ticketCount = 100; // 一共有一百张票

    @Override
    public void run() {
        while (true) {
            if (method()) {
                break;
            }
        }
    }

    private synchronized boolean method() {
        // 如果票的数量为0 , 那么停止买票
        if (ticketCount <= 0) {
            return true;
        } else {
            // 模拟出票的时间
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 有剩余的票 , 开始卖票
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
            return false;
        }
    }
}

java

package com.fan.synchronized_demo2;

/*
    1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    2 在Ticket类中重写run()方法实现卖票，代码步骤如下
        A：判断票数大于0，就卖票，并告知是哪个窗口卖的
        B：票数要减1
        C：卖光之后，线程停止
    3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
        A：创建Ticket类的对象
        B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
        C：启动线程

 */
public class TicketDemo {
    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();
    }
}

6.5 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock中提供了获得锁和释放锁的方法
    void lock()：获得锁
    void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
    ReentrantLock的构造方法
    ReentrantLock()：创建一个ReentrantLock的实例

注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用

java

package com.fan.synchronized_demo3;

import java.util.concurrent.locks.ReentrantLock;

/*
    虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
    为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

    Lock中提供了获得锁和释放锁的方法
        void lock()：获得锁
        void unlock()：释放锁

    Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
        ReentrantLock的构造方法
        ReentrantLock()：创建一个ReentrantLock的实例

    注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用

 */
public class Ticket implements Runnable {
    private int ticketCount = 100; // 一共有一百张票
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();// 加锁
                // 如果票的数量为0 , 那么停止买票
                if (ticketCount <= 0) {
                    break;
                } else {
                    // 模拟出票的时间
                    Thread.sleep(100);
                    // 有剩余的票 , 开始卖票
                    ticketCount--;
                    System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();// 释放锁
            }
        }
    }
}

java

package com.fan.synchronized_demo3;

/*
    1 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    2 在Ticket类中重写run()方法实现卖票，代码步骤如下
        A：判断票数大于0，就卖票，并告知是哪个窗口卖的
        B：票数要减1
        C：卖光之后，线程停止
    3 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
        A：创建Ticket类的对象
        B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
        C：启动线程

 */
public class TicketDemo {
    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();
    }
}

Lock和synchronized区别(悲观锁和乐观锁的区别)

java

a. Lock属于乐观锁,使用多个线程操作的是同一个变量
   synchronized属于悲观锁,使用多个线程操作一段代码
b.
   乐观锁:线程A在操作变量时,允许线程B操作,只是会先判断,如果有问题,就放弃本次操作.判断如果没有问题,就会正常操作
   悲观锁:当线程A正在操作的时候,不允许线程B执行,要等A出来之后B才有可能进入执行

c.相对来说,悲观锁效率比较低,乐观锁效率比较高

当多线程操作同一个数据时,会出现以下问题:

1.可见性

java

i=9，变量i的初始值为9，每一个线程的操作都是减1。两个线程A与B同时访问变量，B先执行i-1,在将结果i=8同步到内存中，A线程也执行i-1，这时i=9的状态就被执行两次，出现线程安全问题。

线程安全问题产生的原因：一个线程对共享数据的修改不能立即被其他线程所见。

解决:给共享的变量加上关键字:volatile

2.有序性

java

多行代码的编写顺序和编译顺序。
有些时候，编译器在编译代码时，为了提高效率，会对代码“重排”：

.java文件
int a = 0;		//第一行
int b = 20;		//第二行
int c = a / b;	//第三行

在执行第三行之前，由于第一行和第二行的先后顺序无所谓，所以编译器可能会对“第一行”和“第二行”进行代码重排：
.class
int b = 20;
int a = 0;
int c = a / b;

但在多线程环境下，这种重排可能是我们不希望发生的，因为：重排，可能会影响另一个线程的结果,所以我们不需要代码进行重排

解决:给共享的变量加上关键字:volatile

3.原子性

java

指的是一个操作不可中断，即在多线程并发的环境下，一个操作一旦开始，就会在同一个CPU时间片内执行完毕

volatile解决不了原子性问题,所以为了多线程操作同一个数据出现的原子性问题,我们可以使用原子类

Atomicxxx类->xxx代表具体数据类型  ->  原子类的实现原理就是乐观锁

java

public class Test02 {
 public static void main(String[] args) {
     //原子类
     AtomicInteger i = new AtomicInteger();//int i = 0
     /*int addAndGet(int delta)以原子方式将给定值与当前值相加。*/
     int i1 = i.addAndGet(2);
     System.out.println(i1);
 }
}

7 线程死锁

7.1 概述 :

死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的

7.2 产生条件 :

多个线程
存在锁对象的循环依赖

7.3 代码实践

java

package com.fan.deadlock_demo;

/*
    死锁 :
        死锁是一种少见的，而且难于调试的错误，在两个线程对两个同步锁对象具有循环依赖时，就会大概率的出现死锁。
        我们要避免死锁的产生。否则一旦死锁，除了重启没有其他办法的
 */
public class DeadLockDemo {
    public static void main(String[] args) {
        String 筷子A = "筷子A";
        String 筷子B = "筷子B";

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (筷子A) {
                        System.out.println("小白拿到了筷子A ,等待筷子B....");
                        synchronized (筷子B) {
                            System.out.println("小白拿到了筷子A和筷子B , 开吃!!!!!");
                        }
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "小白").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (筷子B) {
                        System.out.println("小黑拿到了筷子B ,等待筷子A....");
                        synchronized (筷子A) {
                            System.out.println("小黑拿到了筷子B和筷子A , 开吃!!!!!");
                        }
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "小黑").start();
    }
}

8 线程的状态

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Terminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。或者调用过时方法stop()

线程状态图：

9 线程通信

线程间的通讯技术就是通过等待和唤醒机制，来实现多个线程协同操作完成某一项任务，例如经典的生产者和消费者案例。等待唤醒机制其实就是让线程进入等待状态或者让线程从等待状态中唤醒，需要用到两种方法，如下：
等待方法 :
- void wait() 让线程进入无限等待。
- void wait(long timeout) 让线程进入计时等待
- 以上两个方法调用会导致当前线程释放掉锁资源。
唤醒方法 :
- void notify() 唤醒在此对象监视器（锁对象）上等待的单个线程。
- void notifyAll() 唤醒在此对象监视器上等待的所有线程。
- 以上两个方法调用不会导致当前线程释放掉锁资源
注意
- 等待和唤醒的方法，都要使用锁对象调用（需要在同步代码块中调用)
- 等待和唤醒方法应该使用相同的锁对象调用

java

package com.fan.waitnotify_demo;

/*
    1 线程进入无限等待
        注意：进入无限等待需要使用锁在同步代码中调用wait方法
 */
public class Test1 {
    public static void main(String[] args) {
        Object obj = new Object(); // 作为锁对象

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    System.out.println("线程开始执行");
                    System.out.println("线程进入无线等待....");
                    try {
                        obj.wait(); // 进入无线等待状态 , 并释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("无线等待被唤醒....");
                }
            }
        }).start();
    }
}

java

package com.fan.waitnotify_demo;

/*
    线程进入无限等待后被唤醒
    注意：等待和唤醒是两个或多个线程之间实现的。进入无限等待的线程是不会自动唤醒，只能通过其他线程来唤醒。
 */
public class Test2 {
    public static void main(String[] args) {
        Object obj = new Object(); // 作为锁对象

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    System.out.println("线程开始执行");
                    System.out.println("线程进入无线等待....");
                    try {
                        obj.wait(); // 进入无线等待状态 , 并释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("无线等待被唤醒....");
                }
            }
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj) {
                    obj.notify();// 随机唤醒此监视器中等待的线程 , 不会释放锁
                    System.out.println("唤醒后 , 5秒钟后释放锁");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }// 释放锁
            }
        }).start();
    }
}

java

package com.fan.waitnotify_demo;

/*
    3 线程进入计时等待并唤醒
        注意：进入计时等待的线程，时间结束前可以被其他线程唤醒。时间结束后会自动唤醒
 */
public class Test3 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (Test3.class) {
                    System.out.println("获取到锁 , 开始执行");
                    try {
                        System.out.println("进入计时等待...3秒");
                        Test3.class.wait(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("自动唤醒.");
                }
            }
        }).start();
    }
}

生产者和消费者案例

java

package com.fan.waitnotify_demo2;

import sun.security.krb5.internal.crypto.Des;

/*
    生产者步骤：
        1，判断桌子上是否有汉堡包
            如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃
 */
public class Cooker implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.flag) {
                        // 桌子上有食物
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        // 桌子上没有食物
                        System.out.println("厨师生产了一个汉堡包...");
                        Desk.flag = true;
                        Desk.lock.notify();
                    }
                }
            }
        }
    }
}

java

package com.fan.waitnotify_demo2;

import sun.security.krb5.internal.crypto.Des;

/*
    消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
            叫醒等待的生产者继续生产
            汉堡包的总数量减一
 */
public class Foodie implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.flag) {
                        // 桌子上有食物
                        System.out.println("吃货吃了一个汉堡包...");
                        Desk.count--; // 汉堡包的数量减少一个
                        Desk.flag = false;// 桌子上的食物被吃掉 , 值为false
                        Desk.lock.notify();
                    } else {
                        // 桌子上没有食物
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

java

package com.fan.waitnotify_demo2;

public class Test {
    public static void main(String[] args) {
        new Thread(new Foodie()).start();
        new Thread(new Cooker()).start();
    }
}

10 线程池

1683614628519

10.1 线程使用存在的问题

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。如果大量线程在执行，会涉及到线程间上下文的切换，会极大的消耗CPU运算资源

10.2 线程池的介绍

其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

10.3 线程池使用的大致流程

创建线程池指定线程开启的数量
提交任务给线程池，线程池中的线程就会获取任务，进行处理任务。
线程处理完任务，不会销毁，而是返回到线程池中，等待下一个任务执行。
如果线程池中的所有线程都被占用，提交的任务，只能等待线程池中的线程处理完当前任

10.4 线程池的好处

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要等待线程创建 , 就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存 (每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

10.4 Java提供好的线程池

java.util.concurrent.ExecutorService 是线程池接口类型。使用时我们不需自己实现，JDK已经帮我们实现好了
获取线程池我们使用工具类java.util.concurrent.Executors的静态方
- public static ExecutorService newFixedThreadPool (int num) : 指定线程池最大线程池数量获取线程池
线程池ExecutorService的相关方法
- <T> Future<T> submit(Callable<T> task)
- Future<?> submit(Runnable task)
关闭线程池方法（一般不使用关闭方法，除非后期不用或者很长时间都不用，就可以关闭）
- void shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务

10.5 线程池处理Runnable任务

java

package com.fan.threadpool_demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    1 需求 :
        使用线程池模拟游泳教练教学生游泳。
        游泳馆（线程池）内有3名教练（线程）
        游泳馆招收了5名学员学习游泳（任务）。

    2 实现步骤：
        创建线程池指定3个线程
        定义学员类实现Runnable，
        创建学员对象给线程池
 */
public class Test1 {
    public static void main(String[] args) {
        // 创建指定线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        // 提交任务
        threadPool.submit(new Student("小花"));
        threadPool.submit(new Student("小红"));
        threadPool.submit(new Student("小明"));
        threadPool.submit(new Student("小亮"));
        threadPool.submit(new Student("小白"));

        threadPool.shutdown();// 关闭线程池
    }
}

class Student implements Runnable {
    private String name;

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

    @Override
    public void run() {
        String coach = Thread.currentThread().getName();
        System.out.println(coach + "正在教" + name + "游泳...");

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(coach + "教" + name + "游泳完毕.");
    }
}

10.6 线程池处理Callable任务

java

package com.fan.threadpool_demo;

import java.util.concurrent.*;

/*
    需求: Callable任务处理使用步骤
        1 创建线程池
        2 定义Callable任务
        3 创建Callable任务，提交任务给线程池
        4 获取执行结果

    <T> Future<T> submit(Callable<T> task) : 提交Callable任务方法    
    返回值类型Future的作用就是为了获取任务执行的结果。
    Future是一个接口，里面存在一个get方法用来获取值

    练一练：使用线程池计算 从0~n的和，并将结果返回
 */
public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建指定线程数量的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        Future<Integer> future = threadPool.submit(new CalculateTask(100));
        Integer sum = future.get();
        System.out.println(sum);
    }
}

// 使用线程池计算 从0~n的和，并将结果返回
class CalculateTask implements Callable<Integer> {
    private int num;

    public CalculateTask(int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;// 求和变量
        for (int i = 0; i <= num; i++) {
            sum += i;
        }
        return sum;
    }
}

异常,多线程 ​

1 异常的概述 ​

1.1 什么是异常? ​

1.2 异常的存在的形式 ​

1.3 程序中异常产生后，是如何处理的 ​

2 异常的分类 ​

3 异常的处理方式 ​

3.1 JVM处理异常的方式 ​

3.2 手动处理异常方式 ​

3.2.1 声明异常 ​

3.2.2 抛出异常 ​

思考： ​

格式 : ​

注意 : ​

作用 : ​

3.2.3 throws和throw的区别 ​

3.2.4 捕获异常 ​

3.3 打印异常信息的三个方法 ​

3.4 异常练习 ​

4 自定义异常 ​

4.1 概述 ​

4.2 实现步骤 ​

4.3 自定义异常注意 ​

5 多线程入门 ​

5.1 多线程相关的概念 ​

5.2 什么是多线程 ​

5.3 多线程的创建方式 ​

5.3.1 继承Thread方式 ​

5.3.2 实现Runable方式 ​

5.3.3 Thread类中常用方法 ​

6 线程安全 ​

6.1 线程安全产生的原因 ​

注意 : 以上代码是有问题 , 接下来继续改进 ​

通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题 ​

6.2 线程的同步 synchronized ​

6.3 同步代码块 ​

6.4 同步方法 ​

6.5 Lock锁 ​

Lock和synchronized区别(悲观锁和乐观锁的区别) ​

7 线程死锁 ​

7.1 概述 : ​

7.2 产生条件 : ​

7.3 代码实践 ​

8 线程的状态 ​

9 线程通信 ​

生产者和消费者案例 ​

10 线程池 ​

10.1 线程使用存在的问题 ​

10.2 线程池的介绍 ​

10.3 线程池使用的大致流程 ​

10.4 线程池的好处 ​

10.4 Java提供好的线程池 ​

10.5 线程池处理Runnable任务 ​

10.6 线程池处理Callable任务 ​

异常,多线程

1 异常的概述

1.1 什么是异常?

1.2 异常的存在的形式

1.3 程序中异常产生后，是如何处理的

2 异常的分类

3 异常的处理方式

3.1 JVM处理异常的方式

3.2 手动处理异常方式

3.2.1 声明异常

3.2.2 抛出异常

思考：

格式 :

注意 :

作用 :

3.2.3 throws和throw的区别

3.2.4 捕获异常

3.3 打印异常信息的三个方法

3.4 异常练习

4 自定义异常

4.1 概述

4.2 实现步骤

4.3 自定义异常注意

5 多线程入门

5.1 多线程相关的概念

5.2 什么是多线程

5.3 多线程的创建方式

5.3.1 继承Thread方式

5.3.2 实现Runable方式

5.3.3 Thread类中常用方法

6 线程安全

6.1 线程安全产生的原因

注意 : 以上代码是有问题 , 接下来继续改进

通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题

6.2 线程的同步 synchronized

6.3 同步代码块

6.4 同步方法

6.5 Lock锁

Lock和synchronized区别(悲观锁和乐观锁的区别)

7 线程死锁

7.1 概述 :

7.2 产生条件 :

7.3 代码实践

8 线程的状态

9 线程通信

生产者和消费者案例

10 线程池

10.1 线程使用存在的问题

10.2 线程池的介绍

10.3 线程池使用的大致流程

10.4 线程池的好处

10.4 Java提供好的线程池

10.5 线程池处理Runnable任务

10.6 线程池处理Callable任务