Java编程笔记第八章：异常与多线程

最新推荐文章于 2022-07-08 09:23:16 发布

雨巷sky

最新推荐文章于 2022-07-08 09:23:16 发布

阅读量259

点赞数

分类专栏：简史不是捡屎

本文链接：https://blog.csdn.net/qq_28168643/article/details/88537978

版权

简史不是捡屎专栏收录该内容

11 篇文章 0 订阅

订阅专栏

8.1 异常

8.1.1 异常的概念和异常体系

异常：指的是在程序运行过程中出现的非正常的现象，最终会导致JVM的非正常停止
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就会创建异常对象并且抛出异常对象交给虚拟机处理。Java处理异常的方式是中断处理

异常体系：
异常机制就是帮助我们找到程序中出现的问题，异常的跟类是java.lang.Throwable,下面有两个子类：java.lang.Error、java.lang.Exception,平常所说的异常指的是Exception

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.2 异常分类

java.lang.Throwable：是Java语言中所有错误或异常的超类。
Error：严重错误Error，无法通过处理的错误，只能事先避免。
Exception：编译期异常，就是编译（写代码)Java程序出现的问题。

举例说明：

package cn.itcast.day13;

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

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 13:31
 * @since JDK8u191
 */
public class ExceptionTest {
    public static void main(String[] args) /*throws ParseException  处理方式1*/ {
        //Exception:编译期异常，编译代码时出现的异常
        //格式化日期
        SimpleDateFormat s = new SimpleDateFormat("yyyy MM dd");
        //处理方式2
        Date date = null;
        try {
            //把字符串日期解析为Date格式日期
            date = s.parse("2019-03-13");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);
        System.out.println("后续代码");


        //运行期异常RuntimeException:运行期异常，Java程序运行过程中出现的问题
        int[] arr = {1,2,3};
        //System.out.println(arr[0]);
        try{
            //可能会出现异常的代码
            System.out.println(arr[3]);
        }catch (Exception e){
            //异常的处理逻辑
            System.out.println(e);
        }

        //错误异常Error 内存溢出，创建数组长度太大，必须修改源码。
        int[] arr01 = new int[1024*1024*1024];
        System.out.println(arr01.length);
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.3 异常的产生过程解析

首先写出异常代码

package cn.itcast.day13;

/**
 * 分析异常
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 15:54
 * @since JDK8u191
 */
public class DemoException {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        //由于arr数组没有第三个索引，所以程序会抛出异常
        int e = getElement(arr,3);
        System.out.println(e);
    }

    public static int getElement(int[] arr,int index){
        int ele = arr[index];
        return ele;

//输出异常为：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
//		  	at cn.itcast.day13.DemoException.getElement(DemoException.java:18)
//			at cn.itcast.day13.DemoException.main(DemoException.java:13)

    }
}

分析上面代码异常：

第一步：通过调用getElement方法访问数组中的3索引，而数组是没有第三个索引的，这时候JVM就会检测出程序出现异常。然后JVM会做两件事情：
① JVM会根据异常产生的原因创建一个异常对象，这个对象包含异常产生的（内容，原因，位置）。
② 在getElement方法中，没有异常的处理逻辑（try…catch…），那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常。
第二步：main方法接收到了这个异常对象，main方法也没有这个异常的处理逻辑继续把异常对象抛出给main方法的调用者JVM处理。
第三步 JVM接收到了这个异常对象，做了两件事情：
①把异常对象（内容，原因，位置）以红色的字体打印在控制台上。
②JVM会终止当前正在执行的Java程序–>中断处理。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.4 异常的处理

Throw关键字

作用：
可以使用throw关键字在指定的方法中抛出指定的异常
使用格式：
throw new xxxException(“异常产生的原因”)
注意：
1. throw关键字必须写在方法内部
2. throw关键字后边new的对象必须是Exception或者Exception的子对象
3. throw关键字抛出指定的异常对象，我们就必须处理这个异常对象：
如果 throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以默认交给JVM来处理（打印异常对象，中断程序）。
如果 throw关键字后边创建的是编译异常，我们就必须处理，要么throw，要么try…catch…

package cn.itcast.day13;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 16:36
 * @since JDK8u191
 */
public class ThrowTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int s = getElement(arr,3);
    }
    //定义一个方法，获取数组指定索引的元素
    //以后在工作中，必须首先对方法传递过来的参数进行合法性校验
    //如果参数不合法，必须使用抛出异常的方式告知方法的调用者，传递的参数有问题
    public static int getElement(int[] arr,int index){
        if (arr == null){
            throw new NullPointerException("传递的数组值为null");
        }
        /*
        还可以对传递过来的参数index进行合法性校验
        如果index的范围不在数组范围之类
        那么我们就抛出数组索引越界异常，告知方法的调用者“传递的索引超出数组使用范围”
         */
        if (0 > index || index > arr.length-1){
            throw new ArithmeticException("传递的索引超出数组使用范围");
        }
        int ele = arr[index];
        return ele;
    }
}

Objects非空判断

Objects类中的静态方法：

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

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

package cn.itcast.day13;

import java.util.Objects;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 16:55
 * @since JDK8u191
 */
public class ObjectsTest {
    public static void main(String[] args) {
        method(null);
    }

    public static void method(Object obj) {
        //对传递过来的参数进行合法性判断，判断是否为null
        //方法1   if (obj == null){
        //方法2   throw new NullPointerException("传递的对象的值为null");
        //        }
        //        Objects.requireNonNull(obj);
        Objects.requireNonNull(obj, "传递的对象的值为null");

    }
}

throws关键字，异常处理的第一种方法

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
声明异常格式：
修饰符返回值类型方法名(参数) throws 异常类名1,异常类名2…{
}
代码：

package cn.itcast.day13;

import java.io.IOError;
import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;

/**
 * 异常处理的第一种方式
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 17:12
 * @since JDK8u191
 */
public class ThrowOne {
//如果声明异常有父子类关系，则声明父类即可
    public static void main(String[] args) throws IOException {  
        readFile("c:\\a.txt");
        readFile("c:\\a.exe");
    }

    public static void readFile(String fileName) throws IOException {
    //定义一个方法，对传递的文件路径进行判断
        if (!fileName.equals("c:\\a.txt")){
            throw new FileAlreadyExistsException("传递文件的路径不是c:\\a.txt");
        }
        //定义一个方法，对文件的后缀名进行判断
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件后缀名不对");
        }
    }
}

异常的第二种处理方式，捕获异常：try…catch…

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

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

格式：
try{
可能出现异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
…
catch（）{//可以有多个catch
}

代码演示：

package cn.itcast.day13;

import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 17:33
 * @since JDK8u191
 */
public class TryCatch {
    public static void main(String[] args){
        try {//可能会产生异常的代码
            readFile("c:\\a.exe");
        }catch (IOException e){//try中抛出声明异常对象，catch就定义声明异常变量，用来接受这个对象
            //异常的捕获逻辑，怎么处理异常对象
            System.out.println("传递的后缀名不是。txt");
        }
        System.out.println("后续代码");
    }

    public static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

获取异常信息你的三个方法

public String getMessage() :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。
public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台。

 try {//可能会产生异常的代码
            readFile("c:\\a.exe");
        }catch (IOException e){//try中抛出声明异常对象，catch就定义声明异常变量，用来接受这个对象
            //异常的捕获逻辑，怎么处理异常对象
            System.out.println(e.getMessage());	//文件后缀名不对
            System.out.println(e.toString());			//java.io.IOException: 文件后缀名不对
            e.printStackTrace();						//java.io.IOException: 文件后缀名不对
                               					  	 //at cn.itcast.day13.TryCatch.readFile(TryCatch.java:26)
                              						  //at cn.itcast.day13.TryCatch.main(TryCatch.java:14)
        }

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.5 fianally代码块

在finally代码块中存放的代码一定会被执行
格式：try{
可能出现异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
处理异常的代码
//记录日志/打印异常信息/继续抛出异常
}
…
catch（）{//可以有多个catch
}finally{
//无论是否出现异常，这块程序都会运行
}

try {//可能会产生异常的代码
            readFile("c:\\a.exe");
        }catch (IOException e){//try中抛出声明异常对象，catch就定义声明异常变量，用来接受这个对象
            //异常的捕获逻辑，怎么处理异常对象
        }finally{
//无论是否出现异常这块代码都会执行
 System.out.println("资源回收");//
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.6 多异常的注意事项

多个异常捕获处理有三种方式：

多个异常分别处理：多个try…catch
多个异常一次捕获，多次处理： 一个try，多个catch
多个异常一次捕获一次处理：一个try，一个catch
一般情况下使用一次捕获多次处理的方式，

注意点：这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理

1.运行时异常被抛出可以不处理。即不捕获也不声明抛出。在这里插入代码片
2.如果finally有return语句,永远返回finally中的结果,建议尽量避免该情况
3.如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
4.父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.1.7 自定义异常类

有时在开发中需要自己自定义异常类
自定义异常类必须继承Exception或者RuntimeException。
定义方式：

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

/**
 * 自定义异常类
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 19:26
 * @since JDK8u191
 */
public class RigisterException extends Exception {
    //定义一个无参构造方法
    public RigisterException(){
      super();
    }
    //定义一个带参数的构造方法继承父类的信息
    public RigisterException(String message){
        super(message);
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2 多线程，线程实现方式

8.2.1 并发与并行

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

8.2.2 线程与进程

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

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.3 创建多线程的第二种方式：创建Thread的子类

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

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

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

/**
 * 主线程
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/13 22:16
 * @since JDK8u191
 */
public class ThreadTest {
//主线程main方法
    public static void main(String[] args) {
        ThreadOne to = new ThreadOne();
        to.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
    }
}
//为方便展示，将代码块移到这
//定义一个类继承Thread类。重写run方法
class ThreadOne extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("run;" + i);
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.4 Thread类的常用方法—获取线程名称

Thread类构造方法：

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

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
获取线程名称的两种方法：

package cn.itcast.day14;

/**
 * 获取线程名称的两种方法
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 15:29
 * @since JDK8u191
 */
public class ThreadGetName {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        //getName获取线程名称第一种方式
        String name = getName();
        System.out.println(name);
        
        //currentThread获取线程名称第二种方式
        Thread t = Thread.currentThread();
        System.out.println(t);
        
        String name1 = t.getName();
        System.out.println(name1);
        //或者可以这样直接调用
		System.out.println(Thread.currentThread().getName());
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.5 Thread类的常用方法—设置线程名称的方法

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 15:46
 * @since JDK8u191
 */
public class ThreadSetName {
    public static void main(String[] args) {
        SetNameMyThread sn = new SetNameMyThread();
        sn.setName("王权");
        sn.start();

        new SetNameMyThread("赵丽颖").start();

    }
}

class SetNameMyThread extends Thread{
    //无参构造方法
    public SetNameMyThread(){}
    //带参构造方法
    public SetNameMyThread(String name){
        //调用父类带参构造方法，把线程名称传递给父类，让父类给子线程起名字
        super(name);
    }
    @Override
    public void run() {
        //获取线程名
        System.out.println(Thread.currentThread().getName());
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.6 Thread类的常用方法—sleep

public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 16:10
 * @since JDK8u191
 */
public class ThreadSleep {
    public static void main(String[] args) {
    //使用for循环打印60次
        for (int i = 1; i <= 60; i++) {
            System.out.println(i);
            try {
            //使用Thread.sleep方法让程序“睡眠”一秒钟
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.7 创建多线程的第二种方式：实现Runnabl接口

实现步骤：

创建一个Runnable接口的实现类。
在实现类中重写Runnable接口的run方法，设置线程任务。
创建一个Runnable接口的实现类对象。
创建Thread对象，构造方法中传递Runnable接口的实现类对象。
调用Thread类中的start方法，开启新的线程执行run方法。

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 16:37
 * @website www.ittimeline.net
 * @since JDK8u191
 */
public class DemoMain{
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
		//创建一个Runnable接口的实现类对象。
        RunnableImpl ri = new RunnableImpl();
        //创建Thread对象，构造方法中传递Runnable接口的实现类对象。
        Thread t = new Thread(ri);
        //调用Thread类中的start方法，开启新的线程执行run方法。
        t.start();
    }
}

/**
 * 1. 创建一个Runnable接口的实现类。
 */
class RunnableImpl implements Runnable {
    @Override		//在实现类中重写Runnable接口的run方法，设置线程任务。
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.8 Thread和Runnabl的区别

实现Runnable接口比继承Thread类所具有的优势：

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

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.2.9 匿名内部类实现线程的创建

匿名内部类的作用：简化代码。
格式：
new 父类/接口（）{
父类/接口中的方法
};

/**
 * 匿名内部内方式实现线程的创建
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 17:00
 * @since JDK8u191
 */
public class InnerClassThread {
    public static void main(String[] args) {
        //使用匿名内部类创建线程
        new Thread() {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "第一种");
                }
            }
        }.start();

        //使用匿名接口实现线程的创建
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "第二种");
                }

            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "第三种");
                }

            }
        }).start();
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3 线程安全问题/线程同步机制

8.3.1 线程安全问题的概述

多线程访问了共享的数据就会产生安全问题
这里通过一个电影院买票的案例来概述
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3.2 线程安全问题代码实现

说明：

多线程可能会抢夺同一条数据，造成多个线程同时执行某段代码，在下面的代码输出结果中，出现了电影院三个窗口（三条线程）同时在卖第100张票，而且会卖出第0张、第-1张票。这就是不安全的体现。我们需要通过同步代码块来解决这一安全问题

/**
 * 买票重复案例
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 17:24
 * @since JDK8u191
 */
public class Ticket {
    public static void main(String[] args) {
        //这里比较简单，不用解释了吧
        RunnableImplTicket run = new RunnableImplTicket();
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        t1.start();
        t2.start();
        t3.start();
    }
}

class RunnableImplTicket implements Runnable{
    //定义票数量ticket为100
    int ticket = 100;
    //实现类重写接口方法
    @Override
    public void run() {
        //使用while死循环来实现卖票的动作
        while (true){
            if (ticket > 0) {
                try {
                    //让线程睡眠10毫秒，提高线程的安全问题，方便理解
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "我在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3.3 线程同步

根据上面的案例提出线程同步的解决方案：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3.4 同步代码块

解决线程安全问题的第一种方案：使用同步代码块
格式：
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
注意点：

同步代码块中的锁对象，可以使用任意对象
必须保证多线程使用的锁对象是同一个
锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行

public class RunnableImplTicket implements Runnable{
    //定义票数量ticket为100
    int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();
    //实现类重写接口方法
    @Override
    public void run() {
        //使用while死循环来实现卖票的动作
        while (true){
            synchronized (obj){
                if (ticket > 0) {
                    try {
                        //让线程睡眠10毫秒，提高线程的问题，全性方便理解
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "我在卖第" + ticket + "张票");
                    ticket--;
                }}
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3.5 同步方法

解决线程安全问题的第二种方案：同步方法
使用步骤：

把访问了共享数据的代码抽取出来，放到一个方法中
在方法中添加synchronized修饰符
格式：定义方法的格式
修饰符 synchronized 返回值类型方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 17:25
 * @since JDK8u191
 */
public class RunnableImplTicket implements Runnable{
    //定义票数量ticket为100
    int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();
    //实现类重写接口方法
    @Override
    public void run() {
        System.out.println("this:" + this);
        //使用while死循环来实现卖票的动作
        while (true){
            synchronized (obj){
                payTicket();
            }
        }
    }

    public /*synchronized*/ void payTicket(){
        synchronized (this){if (ticket > 0) {
            try {
                //让线程睡眠10毫秒，提高线程的问题，全性方便理解
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "我在卖第" + ticket + "张票");
            ticket--;
        }}
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.3.6 Lock锁

解决线程安全问题的第三种方案：Lock锁
java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象

使用步骤：

在成员位置创建一个ReentrantLock对象
在可能出现安全问题的代码前调用Lock接口中的Lock获取锁
在可能出现安全问题的代码后调用Lock接口中的unLock释放锁

package cn.itcast.day14.Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/14 17:25
 * @since JDK8u191
 */
public class RunnableImplTicket implements Runnable {
    //定义票数量ticket为100
    int ticket = 100;
    //1. 在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //实现类重写接口方法
    @Override
    public void run() {
        //使用while死循环来实现卖票的动作
        while (true) {
            //2. 在可能出现安全问题的代码前调用Lock接口中的Lock获取锁
            l.lock();
            if (ticket > 0) {
                try {
                    //让线程睡眠10毫秒，提高线程的问题，全性方便理解
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "我在卖第" + ticket + "张票");
                ticket--;
            }
            //3. 在可能出现安全问题的代码后调用Lock接口中的unLock释放锁
            l.unlock();
        }
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.4 等待与唤醒机制

8.4.1 等待与唤醒案例

package cn.itcast.day16.WaitAndNotify;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/26 18:27
 * @since JDK8u191
 */
public class WaitAndNotify {
    public static void main(String[] args) {
        Object obj = new Object();
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        System.out.println("第一步：告知老板要的包子数量");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("第三步：包子做好了，开始吃包子");
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {//花五秒钟做包子
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj){
                        System.out.println("第二步：花了5s做好了包子，可以开始吃了");
                        obj.notify();}
                }
            }
        }.start();
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.4.2等待唤醒机制

这是多个线程间的一种协作机制。就是在一个线程进行了规定操作后，就进入等待状（wait()），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;在有多个线程进行等待时，如果需要，可以使用 **notifyAll()**来唤醒所有的等待线程

等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知notify”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
notifyAll：则释放所通知对象的 wait set 上的全部线程。

生产者与消费者问题代码实现：

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/24 15:22
 * @since JDK8u191
 */
public class BaoZi {
    String pi;
    String xian;
    //包子的状态，并设置初始值false为没有包子。
    boolean flag = false;
}

包子铺线程

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/24 15:24
 * @since JDK8u191
 */
public class BaoZiPu extends Thread {
    //需要在成员位置创建一个包子对象
    private BaoZi bz;
    //使用带参数的构造方法为这个包子变量赋值
    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        int count = 0;
        //使用while循环，一直生产包子
        while (true){
            //必须保证只有一个线程在执行
            synchronized (bz){
                //对包子的状态判断
                if (bz.flag==true){
                    //包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行，包子铺生产包子
                //增加趣味性，交替生产两种包子
                if (count%2 == 0){
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                }else {
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱馅";
                }
                count++;
                System.out.println("包子铺正在生产" + bz.pi + bz.xian + "包子");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好包子
                //修改状态为有
                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了" + bz.pi + bz.xian + "包子，可以开始吃了");
            }
        }
    }
}

吃货线程

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/24 15:40
 * @since JDK8u191
 */
public class ChiHuo extends Thread{
    private BaoZi bz;

    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        while (true){
            synchronized (bz){
                if (bz.flag == false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃" + bz.pi + bz.xian + "包子");
                //吃完包子修改状态为false
                bz.flag = false;
                //唤醒包子铺线程
                bz.notify();
                System.out.println("吃货已经吃完包子了，包子铺开始生产包子");
                System.out.println("======================================");
            }
        }
    }
}

测试类

package cn.itcast.day16;

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/24 15:46
 * @since JDK8u191
 */
public class Demo {
    public static void main(String[] args) {
        BaoZi bz = new BaoZi();
        new BaoZiPu(bz).start();
        new ChiHuo(bz).start();
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.4.3 Object类中wait带参方法和notifyAll方法

进入到TimeWaiting（计时等待）有两种方式：
1. 使用sleep（long m）方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态。
2. 使用wait（long m）方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，进入到Runnable/Blocked状态。

唤醒的方法：
void notify（）唤醒唤醒在此对象监视器上等待的单个线程，
void notifyAll（）唤醒唤醒在此对象监视器上等待的所有线程。
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.5 线程池

8.5.1 线程池概述

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
有一种办法可以使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务：在Java中可以通过线程池来达到这样的效果。

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

合理利用线程池能够带来三个好处：

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

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

8.5.2 线程池代码实现

package cn.itcast.day16;

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

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/26 19:26
 * @since JDK8u191
 */
public class ThreadPoolTest {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());
    }
}

//2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了新的线程池执行");
    }
}

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

雨巷sky

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java编程笔记第八章：异常与多线程

8.1 异常8.1.1 异常的概念和异常体系异常：指的是在程序运行过程中出现的非正常的现象，最终会导致JVM的非正常停止在Java等面向对象的编程语言中，异常本身是一个类，产生异常就会创建异常对象并且抛出异常对象交给虚拟机处理。Java处理异常的方式是中断处理异常体系：异常机制就是帮助我们找到程序中出现的问题，异常的跟类是java.lang.Throwable,下面有两个子类：java....
复制链接

扫一扫