Java学习第十章(二)

已于 2022-04-14 10:26:38 修改
阅读量563 收藏
点赞数
分类专栏： JAVA学习(进阶班) 文章标签： java 开发语言 学习
于 2022-04-04 17:18:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/123940991
版权

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P797 - P809

目录描述

1.死锁概念

死锁代码需要会写，一般面试官也要求你会写，只有会写，才会在以后的开发中注意这个事情，因为死锁很难调试

死锁示意图：
在这里插入图片描述

package deadlock;

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        //t1和t2两个线程共享o1,o2
        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);

        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread{
    Object o1;
    Object o2;

    public MyThread1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }

    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;

    public MyThread2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }
    }
}

运行结果：

在这里插入图片描述

2.开发中如何解决线程安全问题

  • 第一种方案：尽量使用局部变量代替“实例变量和静态变量”
  • 第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程对应1个对象，100个线程对应100个对象，对象不共享了，就没有数据安全问题了）
  • 第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized【线程同步机制】

注意：不要一上来就选择线程同步synchronized，因为synchronized会让程序的执行效率降低，系统的用户吞吐量降低，用户体验差，在不得已的情况下再选择线程同步机制

3.守护线程

3.1 概述

Java语言中线程分为两大类：用户线程和守护线程【后台线程，例如：垃圾回收器】

守护线程特点：

  1. 一般守护线程是一个四循环
  2. 所有的用户线程只要结束，守护线程自动结束

注意：主线程main方法是一个用户线程
问题：守护线程用在哪？
答：每天零点的时候系统数据自动备份【这个需要使用到定时器，并且可以将定时器设置为守护线程，一直在那里看着，每到零点的时候就备份一次，所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了】

3.2 实现

主要代码： t.setDaemon(true);

package thread;

public class ThreadTest14 {
    public static void main(String[] args) {
        Thread t = new BakDataThread();
        t.setName("备份数据的线程");

        //启动线程之前，将线程设置为守护线程
        t.setDaemon(true);

        t.start();

        //主线程：主线程是用户线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class BakDataThread extends Thread{
    @Override
    public void run() {
        int i = 0;
        //即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止
        while (true){
            System.out.println(Thread.currentThread().getName() + "---->" + (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.定时器 Timer

4.1 概述

定时器作用：间隔特定的时间，执行特定的程序【在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的】
例如：每周要进行银行账户的总账操作；每天要进行数据的备份操作

在java中实现定时器方式：

  1. 使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务，这种方式是最原始的定时器(比较low)
  2. 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用，不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的
  3. 在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务

4.2 实现

使用定时器指定定时任务

package thread;

import javax.xml.crypto.Data;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) throws Exception{
        //创建定时器对象
        Timer timer = new Timer();
        //Timer timer = new Timer(true);

        //指定定时任务
        //timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime  = sdf.parse("2022-04-04 11:00:00");
        timer.schedule(new LogTimerTask(),firstTime,1000 * 10);

        //采样匿名内部类的形式也可以
       /* timer.schedule(new TimerTask(){
            @Override
            public void run() {

            }
        },firstTime,1000 * 10);*/
    }
}

//编写一个定时任务类
//假设是一个记录日志的定时任务
class LogTimerTask extends TimerTask{

    @Override
    public void run() {
        //编写你需要的执行的任务就行了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strtTime  = sdf.format(new Date());
        System.out.println(strtTime + ":成功完成了一次数据备份！");
    }
}

运行结果：

在这里插入图片描述

5.实现线程的第三种方式 Callable

实现Callable接口(JDK8新特性)
特点：这种方式实现的线程可以获取线程的返回值，之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void
优点：可以获取到线程的执行结果
缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;//JUC包下的，属于java的并发包，老JDK中没有这个包，新特性

public class ThreadTest15 {
    public static void main(String[] args) throws Exception{

        //第一步：创建一个”未来任务类“对象
        //参数非常重要，需要给一个Callable接口实现类对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {//call()方法就相当于run方法，只不过这个有返回值
                //线程执行一个任务，执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b;//自动装箱(300结果变成Integer)
            }
        });

        //创建线程对象
        Thread t = new Thread(task);

        //启动线程
        t.start();

        //这里是main方法，这是在主线程中
        //在主线程中，怎么获取t线程的返回结果
        //get()方法的执行会导致”当前线程阻塞“
        Object obj = task.get();
        System.out.println("线程执行结果：" + obj);

        //main方法这里的程序要想执行必须等待get()方法的结束
        //而get()方法可能需要很久，因为get()方法是为了拿另一个线程的执行结果
        //另一个线程执行是需要时间的
        System.out.println("hello world!");
    }
}

6.wait和notify方法

6.1 基础概念

  1. wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的
  2. wait()方法作用：让正在o对象上获得的线程进入等待状态，无期限等待，直到被唤醒为止
Object o = new Object();
o.wait();//该方法的调用，会让“当前线程(正在o对象上活动的线程)”进入等待状态
  1. notify()方法作用：唤醒正在o对象上等待的线程
Object o = new Object();
o.notify();

注意：还有一个notifyAll()方法：唤醒o对象上处于等待的所有线程
在这里插入图片描述

6.2 生产者和消费者模式

在这里插入图片描述

6.3 实现生产者和消费者模式

  1. 使用wait和notify方法实现生产者和消费者模式
  2. 生产者和消费者模式：生产线程负责生产，消费线程负责消费，生产线程和消费线程要达到均衡，这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法
  3. wait方法和notify方法建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题
  4. wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁
  5. notify方法作用：notify()让正在o对象上等待的线程唤醒，只是通知，不会释放掉o对象之前占有的锁

模拟：仓库使用List集合，List集合中假设只能存储1个元素，1个元素就表示仓库满了，如果List集合中元素个数是0，就表示仓库空了，保证List集合中永远都是最多存储1个元素，必须做到这种效果：生成1个消费1个

package thread;

import java.util.ArrayList;
import java.util.List;

public class ThreadTest16 {
    public static void main(String[] args) {
        //创建1个仓库对象，共享的
        List list = new ArrayList();

        //创建两个线程对象
        //生产者线程
        Thread t1 = new Thread(new Producer(list));
        //消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();

    }
}

//生产线程
class Producer implements Runnable{
    //仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直生产(使用死循环来模拟一直生产)
        while (true){
            //给仓库对象list加锁
            synchronized (list){
                if (list.size() > 0){//大于0，说明仓库中已经有1个元素了
                    //当前线程进入等待状态，并且释放list集合的锁
                    try {
                        //当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够执行到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);

                //唤醒消费者消费
                list.notifyAll();
            }

        }

    }
}

//消费线程
class Consumer implements Runnable{
    //仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直消费
        while (true){
            synchronized (list){
                if (list.size() == 0){
                    try {
                        //仓库已经空了
                        //消费者线程等待，释放掉list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够执行到此处说明仓库中有数据，进行消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);

                //唤醒生产者生产
                list.notifyAll();
            }

        }

    }
}

运行结果：

在这里插入图片描述

6.4 编程练习题

题目：
使用生产者和消费者模式实现，交替输出：
假设只有两个线程，输出以下结果：
t1–>1
t2–>2
t1–>3
t2–>4
t1–>5
t2–>6
…
要求：必须交替，并且t1线程负责输出奇数。t2线程负责输出偶数。
两个线程共享一个数字，每个线程执行时都要对这个数字进行：++

代码实现：

package thread;

public class exam01 {
    public static void main(String[] args) {

        //创建共享数字对象
        Num num = new Num();
        //创建两条线程
        //奇数线程
        Thread t1 = new Thread(new OddNum(num));
        //偶数线程
        Thread t2 = new Thread(new EvenNum(num));

        //修改线程名称
        t1.setName("t1");
        t2.setName("t2");

        //启动线程
        t1.start();
        t2.start();
    }
}

//共享数字对象
class Num{
    int i = 1;
}

//偶数线程
class EvenNum implements Runnable{
    //共享数字
    private Num num;

    public EvenNum(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        //死循环i++
        while(true){
            synchronized (num){
                if (num.i % 2 == 1){
                    //如果num是奇数，偶数线程进入等待状态
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序进行到这说明是偶数，输出，并对数字进行++操作
                System.out.println(Thread.currentThread().getName() + "--->" + (num.i++));

                //一秒输出一次
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //唤醒奇数线程(？)
                num.notify();
            }

        }

    }
}

//奇数线程
class OddNum implements Runnable{
    private Num num;

    public OddNum(Num num) {
        this.num = num;
    }

    @Override
    public void run() {
        while (true){
            synchronized (num){
                if (num.i % 2 == 0){
                    try {
                        num.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //执行到这说明是奇数，输出，并对数字进行++操作
                System.out.println(Thread.currentThread().getName() +"--->" + (num.i++));
                //一秒输出一次
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒偶数线程(？)
                num.notify();
            }
        }
    }
}

运行结果：

在这里插入图片描述

计算机量子狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java第十章学习总结
TiAmo___的博客
06-15 221
java第十章学习总结 1.声明字符串的方法： 　　String s=""; 　　String s=new String(“你好”); 2、字符串的长度： 　　字符串.length(); 3、equals 比较的是值，一般用于字符串的比较 　　　== 比较的是地址，一般用户数字的比较 4、equalsIgnoreCase() 比较时忽略大小写 　　toLowerCase() 转换成小写，例：name.toLowerCase(); 　　toUpperCase() 转换成大写，例：name.toUpperCas
java基础入门第二版课后答案第十章，附带学习经验
m0_57066131的博客
06-24 448
第一部分 Java相关以及答案 答案 第二部分算法跟编程 第三部分html&JavaScript&ajax部分 答案 第四部分Javaweb部分 答案 第五部分数据库部分 答案 第六部分XML部分 答案 第七部分.流行的框架与新技术 答案 第八、九部分.软件工程与设计模式以及j2ee部分 写在最后 很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那
java学习课件第二章
12-21
这是第2章内容 这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 第七章、线程 第八章、集合操作 第九章、文件输入输出 第十章、网络编程
JavaOOP 第十章 多线程
云哥的博客
04-12 1610
Java 多线程 文章目录Java 多线程一、学习目标二、进程和线程进程线程三、多线程1、Java 多线程编程2、进程与线程的关系四、`java.lang.Thread`五、主线程六、线程的创建和启动七、继承Thread类创建线程使用继承Thread方式实现八、线程休眠线程休眠的作用：继承Thread类创建单线程九、继承Thread类创建多线程十、实现Runnable接口创建线程十、扩展 实现Callable接口和线程池十一、线程的状态十二、线程调度十三、线程优先级十四、线程的强制运行十五、线程的礼让十六、
大学-Java课程-第十章 输入和输出流
m0_73293867的博客
03-29 156
大学-Java课程-第十章 输入和输出流
Java学习第十章(四)
keith的博客
04-06 1712
获取反射属性Field、反编译Field、通过反射机制访问对象属性、可变长度参数、反射Method、反编译Method、通过反射机制调用方法、反射Constructor、反射机制调用构造方法、获取父类和父类接口
JAVA初步学习——第十章 线程
qq_56078818的博客
09-11 145
java的初级学习
JAVA学习第十章（知识总结）
zhu_yao的博客
04-16 309
1:final关键字(掌握) (1)是最终的意思，可以修饰类，方法，变量。 (2)特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量。 (3)面试相关： A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:常见的给值 定义的时候。(推荐) 构造方法中。 2...
Java基础学习——第十章 枚举类&注解
weixin_47392089的博客
04-06 575
Java基础学习——第十章 枚举类&注解 一、枚举类(enum) 1. 枚举类的概念 枚举类：类的对象只有有限个，确定的 线程状态：创建、就绪、运行、阻塞、死亡 当需要定义一组常量时，强烈建议使用枚举类 若枚举类只有一个对象, 则可以作为一种单例模式的实现方式 枚举类的实现： JDK5.0之前：自定义枚举类 JDK5.0新增：使用enum 关键字定义枚举类 枚举类的属性： 枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰，表示私有常量 枚举类的使用 p
Java就业培训教程第十章
01-21
第10章 Applet10.1浏览器怎样显示网页在学习Applet之前，我们先来看看浏览器是如何显示网页的。浏览器打开网页文件的过程同我们用记事本程序打开文本文件的过程是一样的，只是浏览器会对这个网
使用java理解程序逻辑第十章
05-06
java入门基础，入门宝典，新手学习必备，好东西不容错过！
java第十章答案JAVA多线程——一篇文章让你彻底征服多线程开发
03-24
java第十章答案JAVA多线程——一篇文章让你彻底征服多线程开发
java学习课件 第四章
12-21
这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 第六章、异常处理 第七章、线程 ...第十章、网络编程
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 891
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 898
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1208
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 669
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 226
【代码】Java手动启动jar包。
java黑皮书第十章第4题
06-06
这题是关于Java的多线程编程。 题目描述： 编写一个Java程序，该程序创建两个线程。一个线程输出奇数，另一个线程输出偶数，要求两个线程交替输出。 实现思路： 可以使用两个线程分别输出奇数和偶数，使用一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值