Java进阶13讲__第12讲_2/2

最新推荐文章于 2024-10-08 21:30:52 发布
最新推荐文章于 2024-10-08 21:30:52 发布
阅读量383 收藏 6
点赞数 4
分类专栏： Java进阶13讲 文章标签： java 开发语言 多线程 线程池 线程通信 Executor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaomeiGuiSnJs/article/details/142033200
版权

Ø线程安全问题

Ø线程同步方案

Ø线程池

Ø线程通信

Ø理论补充

1.  线程安全问题

1.1  举例说明

1.2  代码实现

package com.itheima.a_线程安全;

/*
线程安全:
    多个线程同时修改同一个资源

取钱案例
    小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元
    如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

实现步骤
    1. 创建1个账户类，在类中定义账户金额和取钱方法
    2. 创建1个取钱线程类，在类中调用取钱方法
    3. 在主线程中创建1个账户对象代表二人的共享账户
    4. 在主线程中创建2个取钱线程，分别代表小明和小红，并将共享账户对象传递给2个线程处理
    5. 启动2个线程
*/
public class Demo {
    //3. 在主线程中创建1个账户对象代表二人的共享账户
    public static void main(String[] args) {
        Account account = new Account();
        //2. 创建1个取钱线程类，在类中调用取钱方法
        //4. 在主线程中创建2个取钱线程，分别代表小明和小红，并将共享账户对象传递给2个线程处理
        Person xHong = new Person(account);
        Person xMing = new Person(account);
        xMing.setName("小明");
        xHong.setName("小红");
        xMing.start();
        xHong.start();
    }
}

//5. 启动2个线程
class Person extends Thread {
    private Account account;

    public Person(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.drawMoney(100000);
    }
}

//1. 创建1个账户类，在类中定义账户金额和取钱方法
class Account {
    private Integer Money = 100000;

    public void drawMoney(Integer drawMoney) {
        if (drawMoney <= Money) {
            System.out.println(Thread.currentThread().getName() + "取钱" + drawMoney + "元成功");
            Money -= drawMoney;
            System.out.println(Thread.currentThread().getName() + "余额已更新");
            System.out.println(Thread.currentThread().getName() + "余额为：" + Money);
        } else {
            throw new RuntimeException("账户余额不足");
        }
    }
}

2.  线程同步方案

2.1  认识线程同步

2.2  方式一：同步代码块

package com.itheima.b_线程同步_同步代码块;
/*
同步代码块
    把访问共享资源的核心代码给上锁，以此保证线程安全

格式
    synchronized(同步锁){
        访问共享资源的核心代码
    }
原理
    每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
注意
    1、对于当前同时执行的线程来说，同步锁必须是同一把(同一个对象)，否则会出bug注意
    2、同步锁不建议随便使用一个唯一的对象，也能锁住，但可能影响无关线程, 建议使用共享资源作为锁对象
        对于实例方法建议使用this作为锁对象规范
        对于静态方法建议使用字码(类名.class) 对象作为锁对象
*/
public class Account {
    //账户余额
    private Integer balance = 100000;
    //取钱
    public void drawMoney(Integer money) {
        //0.获取线程名称
        //1. 判断余额是否充足
        synchronized (this) {
            if (money > balance) {
                System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
                return;//方法结束
            }
            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");
            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        }
    }
}

2.3  方式二：同步方法

package com.itheima.c_线程同步_同步方法;
/*
同步方法
    把访问共享资源的核心方法给上锁，以此保证线程安全。

格式
    修饰符 synchronized 返回值类型 方法名称(形参列表) {
    	操作共享资源的代码
    }
原理
    每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
    同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
    如果方法是实例方法：同步方法默认用this作为的锁对象。
    如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
*/
public class Account {
    //账户余额
    private Integer balance = 100000;
    //取钱
    public synchronized void drawMoney(Integer money) {
        //0.获取线程名称
        //1. 判断余额是否充足
        if (money > balance) {
            System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
            return;//方法结束
        }
        //2. 如果够,出钱
        System.out.println(Thread.currentThread().getName() + "取钱成功");
        //3. 更新余额
        balance -= money;
        System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
    }
}

2.4  方式三：Lock锁

package com.itheima.d_线程同步_lock锁;

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

/*
Lock锁概述
    Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大
    Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建锁对象
方法
    public ReentrantLock() 创建锁对象
    public void lock()    上锁
    public void unlock() 释放锁
Lock锁使用规范
    规范1、锁对象创建在成员位置，使用final修饰
    规范2、释放锁的代码写在finally块中
*/
public class Account {
    //账户余额
    private Integer balance = 100000;
    private final Lock lock = new ReentrantLock();

    //取钱
    public void drawMoney(Integer money) {
        //0.获取线程名称
        String threadName = Thread.currentThread().getName();
        lock.lock();
        try {
            //1. 判断余额是否充足
            if (money > balance) {
                System.out.println(threadName + "取钱失败,余额不足");
                return;//方法结束
            }
            //2. 如果够,出钱
            System.out.println(Thread.currentThread().getName() + "取钱成功");
            //3. 更新余额
            balance -= money;
            System.out.println(Thread.currentThread().getName() + "取钱之后余额为:" + balance);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

2.5  三种线程同步方法对比

3.  线程池

3.1  认识线程池

3.1.1  定义 

3.1.2  线程池工作原理

3.1.3  线程池的执行流程

3.2  如何创建线程池？

3.3  线程池处理Runnable任务

package com.itheima.e_线程池;

import java.util.concurrent.*;

/*
线程池
    一个可以复用线程的技术
执行流程(核心线程-->工作队列-->临时线程-->拒绝策略)
    判断核心线程数是否已满，如果没满，则创建一个新的核心线程来执行任务
    如果核心线程满了，则判断工作队列是否已满，如果没满，则将任务存储在这个工作队列
    如果工作队列满了，则判断最大线程数是否已满，如果没满，则创建临时线程执行任务
    如果最大线程数已满，则执行拒绝策略
对象创建
    接口 ExecutorService
    实现类 ThreadPoolExecutor
        int corePoolSize : 指定线程池的核心线程的数量
        int maximumPoolSize：指定线程池的最大线程数量
        long keepAliveTime ：指定临时线程的存活时间
        TimeUnit unit：指定临时线程存活的时间单位
        BlockingQueue<Runnable> workQueue：指定线程池的任务队列
        ThreadFactory threadFactory：指定线程池的线程工厂
        RejectedExecutionHandler handler：指定线程池的任务拒绝策略
*/
public class Demo1 {
    public static void main(String[] args) {
        ExecutorService es = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(es);
        //核心线程
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        //等待队列
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        //临时线程
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
            try {
                Thread.sleep(25000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        es.execute(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("执行任务");
        });
        System.out.println(es);
        //提交多次任务
//        for (int i = 0; i < 10; i++) {
//            es.execute(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread());
//                    System.out.println("执行任务");
//                }
//            });
//        }

    }
}

3.4  线程池处理Callable任务

package com.itheima.e_线程池;

import java.util.concurrent.*;

/*
线程池执行Runnable任务
    Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo3 {
    public static void main(String[] args) throws Exception {
        ExecutorService es = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(es);
        Future<Integer> future = es.submit(() -> {
            int count = 0;
            for (int i = 0; i < 11; i++) {
                if (i % 2 == 0) {
                    //遇到偶数休眠两秒
                    Thread.sleep(2000);
                }
                count += i;
            }
            return count;
        });
//        System.out.println("count:" + future.get());
        System.out.println("count:" + future.get(5, TimeUnit.SECONDS));
    }
}

案例

package com.itheima.e_线程池;

import java.util.concurrent.*;

/*
线程池执行Runnable任务
    Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo3 {
    public static void main(String[] args) throws Exception {
        ExecutorService es = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(es);
        Future<Integer> future = es.submit(new MyTask(10));
        System.out.println(future.get());
        Future<Integer> future1 = es.submit(new MyTask(5));
        System.out.println(future1.get());
        Future<Integer> future2 = es.submit(new MyTask(100));
        System.out.println(future2.get());
        es.shutdown();
        System.out.println(es);
    }
}

//需求: 编写一个任务类, 可以通过构造器接收n, 计算并返回1~n的和
class MyTask implements Callable<Integer> {
    private int n;

    public MyTask(int n) {
        this.n = n;
    }

    /**
     * 计算1-n的和
     *
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

3.5  Executors工具类实现线程池

面试可能会问，了解

4.  线程通信(了解)

5.  理论补充

5.1  进程与线程

5.2  并发与并行

5.2.1  并发

5.2.2  并行

5.3  线程生命周期

不再会有谎言
关注
专栏目录
Java进阶学习资料.zip
06-21
在Java进阶学习中，你需要掌握以下几个关键的知识点： 1. 高级数据结构与算法：理解并能熟练运用ArrayList、LinkedList、HashMap等集合框架，深入研究Set、Queue、Stack等接口及其实现类。同时，学习并应用高级排序...
Java语言程序设计 第10版 进阶篇 中文part2（共2部分） Y.Daniel Liang 梁勇
07-26
《Java语言程序设计 第10版 进阶篇》是由著名计算机教育家Y. Daniel Liang和梁勇共同编著的一本权威Java编程教材。...通过学习本书，读者不仅可以巩固Java进阶知识，还能为实际项目开发打下坚实的基础。
JAVA入门到进阶视频教程_JavaSE从入门到进阶视频教程
weixin_35797090的博客
02-27 140
JavaSE从入门到进阶视频教程，由源码时代(www.itsource.cn)讲师原创录制！转载请注明出处。教程列表：04_常用的DOS命令03_计算机相关常识了解02_今日课程介绍11_JDK的安装10_JDK的卸载09_相关术语了解JVM-JRE-JDK08_Java的跨平台原理07_Java语言的版本介绍06_编程语言了解05_常用的快捷键01_课程介绍21_Editplus配置编译运行Ja...
java进阶篇_Java教程-Java零基础（进阶篇）
weixin_36166988的博客
02-12 731
Hi，大家好，小蛙又来了。小蛙趁着今天阳光明媚，万里无云的好天气就给给大家介绍另一套的基础教程视频是进阶篇的，通俗点讲也就是JavaSE。一般情况下的小萌新通常会问，什么是JavaSE呢？JavaSE能做什么呢？JavaSE是什么呢？能做什么呢？Java SE 是Java平台标准版的简称(Java Platform, Standard Edition) (also known as Java 2 ...
Java进阶学习之路
m0_50249028的博客
03-04 937
Java进阶学习之路：也是博主学习整理的东西，目前还在跟进中，主要包含java基础，java进阶，javaWeb，框架：ssm，springMvc，SpringBoot
Java进阶课程笔记免费分享_资源整合帖
BHSZZY的博客
11-09 2227
一、前言 最近本人报了一个《拉勾教育Java高薪训练营》，花了9800元，算是为了提高自己（的薪资）的投资吧。 课程有12个阶段，每个阶段有一堆模块，全部学完预计得6个月…… 在此，本人准备把每个模块的笔记整理出来，免费分享给大家，一起学习进步，如果有什么问题，欢迎留言沟通。 笔记内容保证干货，假一赔一！（如有大佬指出错误，本人一定修改，赔您一篇正确的笔记^_^） 其实主要是想证明自己没有白学，钱没有白花！ 二、Java进阶课程笔记链接（笔记会定期更新） 第一阶段 开源框架源码剖析 模.
java进阶项目mvc框架_Java高级进阶技术之SpringMVC框架从入门到精通
weixin_30064949的博客
03-01 99
Java高级进阶技术之SpringMVC框架从入门到精通爱丝**的梦Java2019-09-01https://www.jsdaima.com/video/831.htmlJava高级进阶技术之SpringMVC框架从入门到精通课程视频教程下载。本课程讲解的是最新的Spring5版本的MVC，框架包含：动手写MVC框架、SpringMVC开发、源码执行流程分析、注解开发、静态资源访问、处理器请求处...
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
educoder java答案数组进阶_Educoder - Java入门 - 数组基础各关卡题目总结
weixin_42376793的博客
01-14 5652
第1关：初识数组1、编程要求：在Begin-End区域中定义一个int类型数组 scores，录入三个值，91，88，60，最后输出数组中的三个值，效果如图：2、测试效果：3、程序设计思路：(1)利用数组的省略静态创建法快速创建数组，再按照索引值对应输出数组中的元素值。4、程序实现：package step1;public class HelloWorld {public static void ...
Java进阶-Java Stream API详解与使用
踏雨歌青春，诗酒趁年华
04-28 9615
本文全面介绍了 Java Stream API 的概念、功能以及如何在 Java 中有效地使用它进行集合和数据流的处理。通过详细解释和示例，文章展示了 Java Stream API 在简化代码、提高效率以及支持函数式编程方面的优势。文中还比较了 Java Stream API 与其他集合处理库的异同，强调了其在现代 Java 开发中的重要性和实用性。
java学习进阶之路，如果从一个菜鸟进阶成大神
2401_85377564的博客
07-16 1152
金三银四到了，送上一个小福利！现原理）ORM，DAO4：JavaWeb核心技术（包括部分前端）Html5/Css/JS原生/jQueryAjax（跨域等）JSFJSONEJB序列化和反序列化规则引擎搜索引擎模板引擎缓存身份认证测试集群金三银四到了，送上一个小福利！[外链图片转存中…(img-gQlTIu5G-1721139927380)][外链图片转存中…(img-SCbjEAjK-1721139927381)]
超详细java进阶知识点笔记
weixin_43917227的博客
01-22 3930
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 java进阶前言一、final关键字1.对final的基本认识2.被final修饰后的特点二、常量1.final和static结合2.存储三、抽象类1.类与对象2.抽象类3.抽象方法4.抽象的意义四、接口1.接口的初步认识2.接口的实现3.接口的常见异常（ClassCastException）4.接口的意义5.类和类之间的关系6.抽象类和接口的语法上区别：五、包机制1.使用的原因：2.使用方法：3.命名规范4.import机制六、访问控制权
java-ppt.rar_java .ppt_java ppt_java基础 ppt_java基础 ppt_ppt jav
09-21
1. **Java环境搭建**：包括下载JDK（Java Development Kit），设置环境变量如JAVA_HOME, PATH, CLASSPATH，以及如何运行第一个Java程序——经典的"Hello, World!"。 2. **语法基础**：包括数据类型（基本类型如int,...
《Java基础入门》_源代码.zip
01-14
2. **环境搭建**：学习Java的第一步是安装Java Development Kit（JDK），它包含了编译、调试和运行Java程序所需的工具。设置好环境变量JAVA_HOME和Path，确保能够从命令行运行`java`和`javac`命令。 3. **Hello, ...
JDK1.0主要特性
FoolRabbit的专栏
10-06 592
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1368
2024最新Java面试题，针对一些小厂，中厂
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
最新发布
qq_46248151的博客
10-08 523
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1510
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值