day15

最新推荐文章于 2025-03-31 22:48:13 发布
最新推荐文章于 2025-03-31 22:48:13 发布
阅读量100 收藏
点赞数
分类专栏： javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44132400/article/details/104680326
版权
线程的同步

问题的提出

卖票：现有三个窗口共同卖出100张票，模拟这个场景

package java2;

public class Window implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                System.out.println("卖出第"+ticket+"张票");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket--;
            }else{
                break;
            }
        }
    }
}

package java2;

public class test {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

可能会出现错票，重票等现象

理想的状态

在这里插入图片描述

极端状态

在这里插入图片描述

多线程出现了安全问题

问题：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行

Synchronized

Java对于多线程的安全问题提供了专业的解决方式：同步机制

同步代码块：

synchronized (对象){

// 需要被同步的代码；

}

package java2;
/*
使用同步代码块解决继承Thread类的方式的线程安全问题

例子：创建三个窗口卖票，总票数为100张.使用继承Thread类的方式

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
*/
public class Window implements Runnable{
    private int ticket = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println("卖出第" + ticket + "张票");
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

同步方法

package java2;
/*
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
*/
public class Window implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
                fun();
        }
    }
    public synchronized void fun(){
        if (ticket > 0) {
            System.out.println("卖出第" + ticket + "张票");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket--;
        }
    }
}

同步的方式，解决了线程的安全问题。—好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —局限性

同步机制中的锁

synchronized的锁是什么？

任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。

同步方法的锁：静态方法（类名.class）、非静态方法（this）

同步代码块：自己指定，很多时候也是指定为this或类名.class

注意

必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全

一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

同步的范围

如何找问题，即代码是否存在线程安全？

  1. 明确哪些代码是多线程运行的代码
  2. 明确多个线程是否有共享数据
  3. 明确多线程运行代码中是否有多条语句操作共享数据

如何解决呢？（非常重要）

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

即所有操作共享数据的这些语句都要放在同步范围中

切记

范围太小：没锁住所有有安全问题的代码

范围太大：没发挥多线程的功能

释放锁的操作

当前线程的同步方法、同步代码块执行结束

当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。

当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。

不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

单例设计模式之懒汉式(线程安全)

package java2;

public class Singleton {
    Singleton s;
    private  Singleton(){
    }
    public Singleton getS() {
        if (s==null) {
            synchronized (Singleton.class) {
                if (s == null) {
                    s = new Singleton();
                }
            }
        }
        return s;
    }
}

线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

package java2;

public class DeadLock {
    public static void main(String[] args) {
        String s1 = "111";
        String s2 = "222";
        MyThread myThread = new MyThread(s1,s2);
        MyThread2 myThread2 = new MyThread2(s2,s1);
        new Thread(myThread).start();
        new Thread(myThread2).start();
    }
}
class MyThread implements Runnable{
    Object obj1;
    Object obj2;

    public MyThread(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    @Override
    public void run() {
        synchronized (obj1){
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("1111");
            synchronized (obj2){
                System.out.println("2222");
            }
        }
    }
}
class MyThread2 implements Runnable{
    Object obj1;
    Object obj2;

    public MyThread2(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    @Override
    public void run() {
        synchronized (obj1){
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("1111");
            synchronized (obj2){
                System.out.println("2222");
            }
        }
    }
}

解决方法

  1. 专门的算法、原则
  2. 尽量减少同步资源的定义
  3. 尽量避免嵌套同步

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

package java2;

import java.util.concurrent.locks.ReentrantLock;

public class Window implements Runnable{
    private int ticket = 100;
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName()+"卖出第" + ticket + "张票");
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                } else {
                    break;
                }
            lock.unlock();
        }
    }
}

synchronized 与 Lock 的对比

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：

Lock --> 同步代码块（已经进入了方法体，分配了相应资源） --> 同步方法（在方法体之外）

线程的通信

使用两个线程打印 1-100。线程1,线程2 交替打印

package java2;

public class Test01 implements Runnable{
    private int number = 1;
    @Override
    public  void run() {
        synchronized (this) {
            while (true) {
                if (number <= 100) {
                    this.notify();
                    System.out.println(Thread.currentThread().getName() + "打印" + number);
                    number++;
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

package java2;

public class Tets01test {
    public static void main(String[] args) {
        Test01 t = new Test01();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

wait()与notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

notifyAll ()：唤醒正在排队等待资源的所有线程结束等待

这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明

wait() 方法

  1. 在当前线程中调用方法： 对象名.wait()
  2. 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
  3. 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
  4. 调用此方法后，当前线程将释放对象监控权 ，然后进入等待
  5. 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

  1. 在当前线程中调用方法： 对象名.notify()
  2. 功能：唤醒等待该对象监控权的一个/所有线程。
  3. 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

JDK5.0新增线程创建方式

实现Callable接口:

与使用Runnable相比， Callable功能更强大些

  1. 相比run()方法，可以有返回值
  2. 方法可以抛出异常
  3. 支持泛型的返回值
  4. 需要借助FutureTask类，比如获取返回结果
package java2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallTest implements Callable {
    public static void main(String[] args) {
        FutureTask futureTask = new FutureTask(new CallTest());
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("qfdew");
    }
    @Override
    public Object call() throws Exception {
        return "1111";
    }
}

使用线程池

**背景：**经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

**思路：**提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable

Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable

  1. void shutdown() ：关闭连接池
  2. Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
  3. Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
  4. Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
  5. Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
  6. Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
package java2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//用线程池模拟死锁
public class DeadLock {
    public static void main(String[] args) {
        String s1 = "111";
        String s2 = "222";
        MyThread myThread = new MyThread(s1,s2);
        MyThread2 myThread2 = new MyThread2(s2,s1);
        ExecutorService ex = Executors.newFixedThreadPool(3);
        ex.execute(myThread);
        ex.execute(myThread2);
    }
}
class MyThread implements Runnable{
    Object obj1;
    Object obj2;

    public MyThread(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    @Override
    public void run() {
        synchronized (obj1){
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("1111");
            synchronized (obj2){
                System.out.println("2222");
            }
        }
    }
}
class MyThread2 implements Runnable{
    Object obj1;
    Object obj2;

    public MyThread2(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    @Override
    public void run() {
        synchronized (obj1){
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("1111");
            synchronized (obj2){
                System.out.println("2222");
            }
        }
    }
}
day15经典案例.rar_C++经典案列
09-15
这个压缩包文件，"day15经典案例.rar"，显然是一个教学资料集合，可能是某个课程或训练营的第15天教学内容，专门探讨C++的经典应用。 【描述】提到"推荐给学习c++的朋友好好研究一下"，这暗示了这些案例不仅适用于...
句句真研—每日长难句打卡Day15
道阻且长，行则将至。
09-04 5232
句句真研—每日长难句打卡Day15 补九月一号 参考译文：纽约爱乐乐团决定聘请Alan Gilbert作为下一任总监，这项任命自从2009年突然宣布起就一直是古典音乐届谈论的话题。
cgb2106-day15
cgblpx的博客
08-13 5054
标题 标题 标题
软件测试学习DAY15
see_y的博客
09-07 3678
今天的主要内容是测试计划的评审与修改。今天上午通过腾讯会议评审了四个小组的测试计划，老师指出了我们其中存在的问题，下午刚开始，我们修改了测试计划，分配了每个人的任务，开始撰写测试用例，今天下午和晚上我们完成了前台部分中办公模块的测试用例编写。 今天对于测试用例的编写感觉进行的不是很顺利，第一次编写这种没有需求，大型的项目的测试用例，感觉一头乱麻，不知道从何下手。 ...
学习Uni-app开发小程序Day15
qq_34080064的博客
05-17 1504
网络请求的方式写法
Day15_08_Navicat for MySQ中文破解版(无需激活码)安装教程
一一哥
07-04 2168
Navicat for MySQ中文安装教程 一. 下载中文pojieban Navicat for MySQ 链接: https://pan.baidu.com/s/1DO8yJnvTfBndZJ6Hprr7Og 提取码: ik7d 二. 解压下载后的文件 文件中有两个.exe文件,点击navicat111_mysql_cs_x64.exe进行安装 三. 点击PatchN...
CGBTN2111-DAY15总结复习
程序媛泡泡的博客
12-20 4323
DAY15 复习 1. List接口 1.1 List接口的特点 List集合是有下标的 List集合是有顺序的 List集合可以存放重复的数据 1.2 List集合方法总结 单个集合间的操作 void add(int index, E element) 在集合的指定下标index处插入指定元素element E get(int index) 返回本集合中指定下标index处的元素 E remove(int index) 移除本集合中指定下标index处的元素 E set(int index, E e
【springboot】springboot学习笔记day15
guaishounan的博客
09-19 3093
springboot学习笔记day15
OpenCV 学习笔记-day15 随机数与随机颜色（RNG类，RNG::uniform( ) ）
qq_44799835的博客
02-22 4689
OpenCV 学习笔记day15 随机数与随机颜色 day15 随机数与随机颜色 用产生的随机数作为参数标定图形的坐标和颜色，用来产生随机图形和随机颜色 void QuickDemo::random_drawing_demo(Mat &image) { Mat canvas = Mat::zeros(Size(512, 512), CV_8UC3); RNG rng(12345);//产生随机数 while (true) { int c = waitKey(10); if (c ==
day11-15
li13051517725的博客
03-07 4733
day11: could not produce class with ID 74 这个在unity编辑器正常而l2cpp异常那就是配置问题，修改assets下link.xml文件： <linker> <assembly fullname="UnityEngine.AnimationModule"> <type fullname="UnityEngine.AnimationClip"/> </assembly> .
mysql day_MySQL day()函数
weixin_34061241的博客
01-18 1345
在本教程中，您将学习如何使用MySQL DAY函数来获取指定日期的月份的日期(一个月的第几天，也就是表示月份多少日/号)。MySQL DAY函数简介DAY函数返回给定日期的月份的部分。下面显示DAY函数的语法：DAY(date);DAY函数接受一个参数，它是您要获取月份日期的日期值。如果date参数为零，例如'0000-00-00'，则DAY函数返回0，如果日期为，则DAY函数返回NULL值。请注...
Java学习day01-day15学习资料
04-05
这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这部分可能涉及Java的基础语法，如变量、数据类型、运算符、流程控制语句...
python课程设计第15天，python-Day15.rar
05-11
在这个压缩包"python-Day15.rar"中，包含的"Day15"文件很可能是这一天课程的所有材料，包括讲义、代码示例和练习题。 首先，我们可能会接触到Python的模块化编程。模块是Python代码的组织单位，允许我们将大型项目...
java课程设计-test-day15.rar
12-05
考虑到文件名称仅有“day15”，这可能表示该压缩包包含了第15天的课程设计内容或相关材料。具体来说，这可能包含了一些代码示例、参考资料、实验指导书或是项目报告等。由于缺乏具体的文件列表信息，我们无法准确...
【面试八股】：CAS指令
qq_75234423的博客
03-28 731
详细介绍面试八股CAS相关知识点
如何用Java实现100以内素数的判断并输出
算法与编程之美
03-30 235
针对平时经常遇到的问题，我们应该先分析，然后将问题划为不同的几部分，对不同的部分分别分析，然后合理使用方法。此问题中我们主要运用了for语句以及判断语句，在看似不难的问题下，其实还需要多加思考，先理清问题的思路，再找到合理的方法。在以后的使用中，我们应该注意此类问题的通性以及这种用法的使用区域，我们还需要注意此类问题的其他解决方法。进行多层嵌套递归将变量i设为100以内从3开始递增的奇数，j设为另一变量作i的被除数，j小于i的算术平方根，在做运算后自动加1，运用判断语句判断i和j的关系，最后输出。
基于srpingboot智慧校园管理服务平台的设计与实现(源码+文档+部署讲解）
最新发布
qiuyeyyy的博客
03-31 613
管理员在系统中扮演着核心管理角色，其功能涵盖多个重要方面。通过管理员用例图，可以清晰地看到管理员具备对教师信息的全面管理能力，包括教师的入职、离职、信息更新以及权限分配等操作；对学生信息的管理，从学生的入学注册到毕业离校，全程跟踪管理学生的个人信息、学业成绩等；课程管理方面，管理员可以创建、编辑和删除课程，安排课程表，确保教学计划的顺利实施；轮播图信息管理，用于展示校园重要通知、活动信息等，吸引师生关注；此外，管理员还负责学生成绩信息的管理，确保成绩数据的准确性和安全性。
MCP(Model Context Protocol，模型上下文协议)
HOKING的专栏
03-27 818
MCP(Model Context Protocol，模型上下文协议)是由 Anthropic 提出并于 2024 年 11 月开源的一种通信协议，旨在解决大型语言模型(LLM)与外部数据源及工具之间无缝集成的需求。它通过标准化 AI 系统与数据源的交互方式，帮助模型获取更丰富的上下文信息，从而生成更准确、更相关的响应。
黑马javaday15
01-10
### 黑马 Java Day 15 课程资料与教程 #### 一、多线程编程基础 在黑马程序员Java培训的第15天，重点讲解了多线程的基础概念及其创建方式。Java中的线程是程序执行流的最小单位，在现代操作系统中可以并发运行多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值