多线程学习笔记2

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量102 收藏
点赞数
分类专栏： 多线程 文章标签： java 线程安全 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59230567/article/details/119537861
版权
本文深入探讨了Java中的多线程安全问题，通过车站卖票实例展示了线程不安全的情况，并介绍了如何使用同步代码块和同步方法来解决这个问题。此外，还讨论了死锁的概念并提供了实现代码。最后，通过生产者消费者问题的代码示例，展示了如何使用锁和条件变量实现线程间的协调。
摘要由CSDN通过智能技术生成

多线程安全问题

  • 多线程访问了共享数据,会产生安全问题
  • 线程不安全的例子如下,最经典的车站卖票实例
//自定义线程类
public class MyRunnable implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        try {
            //睡眠10毫秒，提高线程安全的概率
            Thread.sleep(10);
            while (true){
                if(ticket>0){
                    System.out.println("当前线程"+Thread.currentThread().getName()+"正在买第"+ticket+"张票");
                    ticket--;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//测试类
public class MyTest {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        t1.start();
        Thread t2 = new Thread(mr);
        t2.start();
        Thread t3 = new Thread(mr);
        t3.start();
    }
}

以上代码运行结果截图如下:

线程同步来解决线程安全问题:

  • 同步代码块
  • 同步方法
  • 锁机制

同步代码块

格式:

synchronized(锁对象){

         可能会出现线程安全的代码(访问了共享数据的代码)
}

注意:

通过代码中的锁对象,可以使用任意的对象

但是必须保证多个线程使用的锁对象是同一个

锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行

public class MyRunnable implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
       synchronized(obj){
           try {
               //睡眠10毫秒，提高线程安全的概率
               Thread.sleep(1000);
               while (true){
                   if(ticket>0){
                       System.out.println("当前线程"+Thread.currentThread().getName()+"正在买第"+ticket+"张票");
                       ticket--;
                   }
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}


//测试类
public class MyTest {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        t1.start();
        Thread t2 = new Thread(mr);
        t2.start();
        Thread t3 = new Thread(mr);
        t3.start();
    }
}

同步中的线程,没有执行完毕不会释放锁,同步外的线程没有锁进不去同步

同步方法

使用步骤:

  • 把共享数据的数据抽取出来放在一个方法里,
  • 在方法上添加synchronized修饰符

格式:

修饰符 synchronized 返回值类型 方法名(参数列表){

        可能会出现线程安全的问题的代码(访问了共享数据的代码)

}

public class MyRunnable2 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
       while (true){
           payTicket();
       }
    }

    /*
        同步方法也会把内部的代码锁住，只让一个线程执行，同步方法的锁对象是 new MyRunnable2()
        也就是this
      */
    public synchronized void payTicket(){
        try {
            //睡眠10毫秒，提高线程安全的概率
            Thread.sleep(1000);
            if(ticket>0){
                System.out.println("当前线程"+Thread.currentThread().getName()+"正在买第"+ticket+"张票");
                ticket--;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}



//測試代碼
public class MyTest {
    public static void main(String[] args) {
        MyRunnable2 mr = new MyRunnable2();
        Thread t1 = new Thread(mr);
        t1.start();
        Thread t2 = new Thread(mr);
        t2.start();
        Thread t3 = new Thread(mr);
        t3.start();
    }
}

死锁的实现代码：

public class MyTest {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
//                    线程一
                    synchronized (objB){
                        System.out.println("张三正在走路。。。。");
                    }
                }
            }
        }).start();
        new Thread(()->{
            while (true){
                synchronized (objB){
//                    线程二
                    synchronized (objA){
                        System.out.println("李四正在走路。。。。");
                    }
                }
            }
        }).start();
    }
}

生产者和消费者

需要执行的步骤如图：

代码实现如下：

//标记类 辅助作用
public class Desk {
    /**
        桌子上是否有面包
     */
    public static boolean FLAG = false;
    /**
     * 汉堡的总数
     */
    public static int count = 10;

    /**
     * 锁对象
     */
    public static final Object lock = new Object();

}


/**
 * @author Joshua
 * @since 2021/8/11
 * 消费者步骤：
 *     1、判断桌子上是否有汉堡
 *     2、如果没有就等待
 *     3、如果有就开吃
 *     4、吃完之后，桌子上的汉堡就没有了，叫醒等待的生产者继续生产，汉堡的总数量减1
 */
public class Foodie extends Thread{
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                //如果吃货已经吃了10个，就直接退出
                if(Desk.count<=0){
                    break;
                }else{
                    //判断桌子上是否有汉堡
                    if(Desk.FLAG){
                        //如果有就开吃
                        System.out.println("吃货开始吃汉堡。。。。。真好吃");
                        Desk.FLAG = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    }else{
                        //如果没有就等待
                        //使用什么对象当作锁，就使用什么对象去调用等待和唤醒的方法
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}



/**
 * @author joshua
 * @since 2021/8/11
 * 生成者步骤：
 *     1、判断桌子上是否有汉堡
 *     2、有就等待，没有就生产
 *     3、把汉堡放在桌子上
 *     4、叫醒等待的消费者开吃
 */
public class Cooker extends Thread {
    @Override
    public void run() {
        synchronized (Desk.lock){
            while (true){
                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.notifyAll();
                    }
                }
            }
        }

    }
}


//测试类
public class MyTest {
  
    public static void main(String[] args) {
        Foodie foodie = new Foodie();
        foodie.start();


        Cooker cooker = new Cooker();
        cooker.start();
    }
}

上面代码的Desk类并不符合面向对象，下面进行代码改写

public class Desk {
    /**
        桌子上是否有面包
     */
    public boolean flag;
    /**
     * 汉堡的总数
     */
    public int count ;

    /**
     * 锁对象
     */
    public final Object lock = new Object();

    public Desk() {
        //初始化 flag和count的值
        this(false,10);
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }
}



/**
 * @author Joshua
 * @since 2021/8/11
 * 消费者步骤：
 *     1、判断桌子上是否有汉堡
 *     2、如果没有就等待
 *     3、如果有就开吃
 *     4、吃完之后，桌子上的汉堡就没有了，叫醒等待的生产者继续生产，汉堡的总数量减1
 */
public class Foodie extends Thread{
    private Desk desk;
    public Foodie(Desk desk){
        this.desk = desk;
    }

    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                //如果吃货已经吃了10个，就直接退出
                if(desk.getCount()<=0){
                    break;
                }else{
                    //判断桌子上是否有汉堡
                    if(desk.isFlag()){
                        //如果有就开吃
                        System.out.println("吃货开始吃汉堡。。。。。真好吃");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount()-1);
                    }else{
                        //如果没有就等待
                        //使用什么对象当作锁，就使用什么对象去调用等待和唤醒的方法
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}



/**
 * @author joshua
 * @since 2021/8/11
 * 生成者步骤：
 *     1、判断桌子上是否有汉堡
 *     2、有就等待，没有就生产
 *     3、把汉堡放在桌子上
 *     4、叫醒等待的消费者开吃
 */
public class Cooker extends Thread {
    private Desk desk;
    public Cooker(Desk desk){
        this.desk = desk;
    }
    @Override
    public void run() {
        synchronized (desk.getLock()){
            while (true){
                if(desk.getCount()<=0){
                    break;
                }else{
                    //判断桌子上是否有汉堡
                    if(desk.isFlag()){
                        //有就等待
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //没有就生产
                        System.out.println("大厨正在生产汉堡.....完工。");
                        //把汉堡放在桌子上
                        desk.setFlag(true);
                        //叫醒等待的消费者开吃
                        desk.getLock().notifyAll();
                    }
                }
            }
        }

    }
}




public class MyTest {
    /*
    消费者步骤：
    1、判断桌子上是否有汉堡
    2、如果没有就等待
    3、如果有就开吃
    4、吃完之后，桌子上的汉堡就没有了，叫醒等待的生产者继续生产，汉堡的总数量减1

    生成者步骤：
    1、判断桌子上是否有汉堡
    2、有就等待，没有就生产
    3、把汉堡放在桌子上
    4、叫醒等待的消费者开吃
     */

    public static void main(String[] args) {
        Desk desk = new Desk();

        Foodie foodie = new Foodie(desk);
        foodie.start();


        Cooker cooker = new Cooker(desk);
        cooker.start();
    }
}

使用队列实现生产者消费者的案例

//生产者类
public class Cooker extends Thread {
    private ArrayBlockingQueue<String> list;
    public Cooker(ArrayBlockingQueue<String> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
                list.put("食物");
                System.out.println("厨师向队列中放入食物");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

//消费者类
public class Foodie extends Thread {
    private  ArrayBlockingQueue<String> list;
    public Foodie(ArrayBlockingQueue<String> list) {
        this.list = list;
    }

    @Override
    public void run() {

        while (true){
            try {
                Thread.sleep(100);
                
                System.out.println("吃货从队列中取走"+list.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//测试类

public class MyTest {
    public static void main(String[] args) {
        //创建一个队列 默认容量为1
        ArrayBlockingQueue<String> list = new ArrayBlockingQueue<>(1);
        Foodie foodie = new Foodie(list);
        foodie.start();
        Cooker cooker = new Cooker(list);
        cooker.start();
    }
}

活水774
关注
专栏目录
多线程学习笔记
03-18
多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
JavaSE学习笔记（Day7）
qq_52750266的博客
12-03 433
Day7 Java常用类_API 概述 API(Application Programming Interface)应用程序编程接口 Java程序员在开发Java程序时，只需要安装有Jdk，就可以在程序中使用import关键字导入Java API中指定的包并在自己的程序中使用这些包中定义的各种类和接口。 基本类型包装类 基本数据类型不是面向过程的，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。 包装类（Integer 、Doubl
MySQL基础类型（详细，明了）新手一看就会！
m0_58815937的博客
05-31 452
1、以下哪个单词不是 Java 的关键字？ B A:static B:Boolean C:void D:private 2、java main 函数写法正确的是？ C A: public static void main() B:public void main(String[] args) C:public static void main(String[] args) D:static void main(String[] args) 3、boolean 类型的默认值为？ B A:true B:fals
Java多线程学习笔记
qq_44903634的博客
08-01 1580
wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！其他线程获取“该对象的同步锁”(
Java 多线程学习笔记
2301_76962889的博客
07-13 1889
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3459
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
2024年最全多线程学习笔记2
2301_82242990的博客
05-02 991
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。最大的不同.volatile解决的是变量在多个线程之间的可见性,而synchronized解决的是多个线程之间访问资源的同步性。System.out.println(“线程即将停止”);
C#多线程学习笔记
wangyunman的博客
08-23 798
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
多线程基础学习笔记
旋风小陀螺
03-12 1514
多线程基础学习笔记
Java多线程笔记详解
you are sherlocked by me!
10-09 561
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
Go学习笔记—多线程
koooooooo5的博客
12-01 7185
多线程编程 ​ 一个进程可以包含多个线程，这些线程运行的一定是同一个程序（进程==程序），且都由当前进程中已经存在的线程通过系统调用的方式创建出来。进程是资源分配的基本单位，线程是调度运行的基本单位，线程不可独立于进程存在。 ​ 所有线程都有自己的线程栈，以此存放自己的私有数据（包含在进程的虚拟内存地址中）。一个进程中的很多资源也会被线程所共享，包括在当前进程虚拟内存地址中存放的代码段、数据段、堆、信号处理函数、文件描述符（非负整数）。正因如此，创建一个线程时不会像创建一个进程时那
多线程学习笔记.docx
06-16
在多线程编程中，进程和线程是两个核心概念。进程是操作系统资源分配的基本单位，每个独立执行的程序都对应一个进程。而线程则是程序执行的最小单元，是进程内部的一条执行路径。多线程是指在一个应用程序中存在多个...
多线程 学习笔记.md
05-04
多线程 学习笔记.md
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 707
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 664
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 478
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 761
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
多线程学习笔记：概念与初步实践
"关于多线程学习总结" 在计算机科学中，多线程是并发执行的编程模型，允许程序在同一时间处理多个任务。这种技术尤其在需要优化资源利用和提高响应速度的应用中至关重要。多线程使得程序员能够在一个进程中创建多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值