多线程与高并发day02

已于 2022-06-17 15:38:59 修改
阅读量87 收藏
点赞数
分类专栏： 多线程与高并发 文章标签： java 开发语言
于 2022-06-16 15:09:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yz1925506412/article/details/125309572
版权
本文介绍了如何优雅地结束Java线程，对比了stop(), suspend()与resume(), volatile以及interrupt()方法，并分析了各自的优缺点。同时，探讨了并发编程中的可见性特性，通过实例解释了volatile关键字如何确保线程间变量的可见性，并讨论了缓存行和缓存一致性协议对并发的影响。
摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

个人学习笔记，仅供参考！

1.如何优雅的结束线程

  1. 可使用stop()方法结束线程。stop()方法会直接结束线程并释放做资源，以下代码可进行验证。但是由于stop()方法过于粗暴，无论线程处于何时都会直接结束线程，因此可能在同步方法中进行一半时，被结束，且无善后。所以可能导致数据一致性出现问题。现已废弃，了解即可。
public class day04 {
    static class SleepHelper {
        public static void sleepSeconds(int seconds) {
            seconds *= 1000;
            try {
                Thread.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    static final Object o = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (o) {
                while (true) {
                    System.out.println("t1 go on");
                    SleepHelper.sleepSeconds(1);
                }
            }

        });

        Thread t2 = new Thread(() -> {
            synchronized (o) {
                while (true) {
                    System.out.println("t2 go on");
                    SleepHelper.sleepSeconds(1);
                }
            }

        });

        t1.start();
        SleepHelper.sleepSeconds(1);
        t2.start();
        
        SleepHelper.sleepSeconds(5);

        t1.stop();
    }
}
  1. 使用suspend();与resume();方法组合，可以使线程停止和恢复。但此方法同样过于粗暴，且线程停止时不会释放锁。以下代码可进行验证。在代码中容易因使用不当或特殊情况，造成死锁。已废弃，了解即可。
public class day04 {
    static class SleepHelper {
        public static void sleepSeconds(int seconds) {
            seconds *= 1000;
            try {
                Thread.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    static final Object o = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (o) {
                while (true) {
                    System.out.println("t1 go on");
                    SleepHelper.sleepSeconds(1);
                }
            }

        });

        Thread t2 = new Thread(() -> {
            synchronized (o) {
                while (true) {
                    System.out.println("t2 go on");
                    SleepHelper.sleepSeconds(1);
                }
            }

        });

        t1.start();
        SleepHelper.sleepSeconds(1);
        t2.start();

        SleepHelper.sleepSeconds(5);

        t1.suspend();
        SleepHelper.sleepSeconds(5);

        t1.resume();
    }
}
  1. 使用volatile结束线程。volatile是一种较为优雅的结束线程的一种方式。尽可能不依赖于循环中，中间状态，例如在往一个容器中加入元素，加到第四个时停止，这种情况volatile很难做到精确控制，容易出现偏差；或者说如果，在代码中使用了wait();则可能导致阻塞，无法跳入下一次循环而导致线程无法结束。在特定情况下volatile可以起到不错的作用，且使用较为简便。
public class day04 {
    static class SleepHelper {
        public static void sleepSeconds(int seconds) {
            seconds *= 1000;
            try {
                Thread.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    static final Object o = new Object();
    private static volatile boolean running = true;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (o) {
                while (running) {
                    System.out.println("t1 go on");
                    SleepHelper.sleepSeconds(1);
//                    try {
//                        o.wait();
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                }
            }

        });

//        Thread t2 = new Thread(() -> {
//            synchronized (o) {
//                while (true) {
//                    System.out.println("t2 go on");
//                    SleepHelper.sleepSeconds(1);
//                }
//            }
//
//        });

        t1.start();
        SleepHelper.sleepSeconds(1);
//        t2.start();

        SleepHelper.sleepSeconds(5);

        running = false;
    }
}
  1. interrupt结束线程，这是一种非常优雅的结束线程的方式。且就算代码处于sleep();或处于wait();时只要可以正确处理因为interrupt();产生的报错，线程依然能优雅的结束。
public class day04 {
    static class SleepHelper {
        public static void sleepSeconds(int seconds) {
            seconds *= 1000;
            try {
                Thread.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }


    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("t1 go on");
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                        Thread.currentThread().interrupt();
//                    }
                }
            System.out.println("end");
        });


        t1.start();
        SleepHelper.sleepSeconds(5);
        t1.interrupt();

    }
}

对于线程结束的方式，以上四种为比较普通的结束方式。如果要做到精确的结束，就需要业务线程与其他线程配合。一些比较精细或者高级的方法，之后会进行记录与讲解。

2.并发编程三大特性

  1. 可见性（visibility）
    从一个程序谈起：
    以下程序，注释volatile与打印语句时，线程不会得到停止。但放开任一注释，线程即可跳出循环继续执行直到结束。这是由于打印语句内部使用了synchronize关键字，而volatile可以保障可见性。
public class day04 {
    static class SleepHelper {
        public static void sleepSeconds(int seconds) {
            seconds *= 1000;
            try {
                Thread.sleep(seconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    private static /*volatile*/ boolean running = true;
    private static  void m(){
        System.out.println("m start");
        while (running){
            //System.out.println("hello");
        }
        System.out.println("m end");
    }
    public static void main(String[] args) {
        new Thread(day04::m,"t1").start();
        SleepHelper.sleepSeconds(1);
        running = false;

    }
}

在这里插入图片描述
在主存中的running为true，当两个线程读取running时，会取出以后copy一份放在线程缓存中， 之后while时读的都是缓存中的copy值。所以线程可见性：一个线程对共享变量值得修改，能够及时的被其他线程看到。

线程可见性原理：
线程一对共享变量的改变想要被线程二看见，就必须执行下面两个步骤：
将工作内存1中的共享变量的改变更新到主内存中
将主内存中最新的共享变量的变化更新到工作内存2中。

关于synchronized：1.线程解锁前，必须把共享变量的最新值刷新到主内存。2.线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中读取最新的值。（加锁与解锁是同一把锁）

关于volatile保障可见性：volatile变量每次被线程访问时，都强迫从主内存中读取该变量的值，而当变量发生变化时会强迫线程将最新的值刷新到主内存中，这样不同的变量总能看到最新的值。

volatile关键字：
能够保证volatile变量的可见性。
只能保证单个volatile变量的原子性，对于volatile++这种复合操作不具有原子性。
volatile引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性。

volatile实现共享变量内存可见性有一个条件，就是对共享变量的操作必须具有原子性。比如一个整数变量num ; 这个操作具有原子性，但是 num++ 或者num–由3步组成，并不具有原子性，所以是不行的。例如：如有一个num，此时有线程1从主内存中获取num的值，并执行++，但还未修改写入主内存，又有线程2取得num的值，进行++操作，造成丢失修改，执行了2次++，num的值只增加1。所以volatile不具有原子性，不适用于计数场景，可以保证原子性操作时，可以尽量的选择使用volatile。在其他不能保证其操作的原子性时，考虑使用synchronized。

关于缓存：
在这里插入图片描述

这是一个多核CPU，左侧为CPU1，右侧为CPU2，L1、L2位于核内部，L3位于CPU内部。几个CPU共享主存。当寄存器需要一个数据时。会去L1读取，L1没有去L2，L2没有去L3，L3也没有就会去主存中读取。当放数据时也是一样，从L3放到L1再到寄存器。我们可见性中说的缓存就是这里的缓存，并不是说的ThreadLocal。

在这里插入图片描述

缓存行概念：计算机将数据从主存读入Cache时，是把要读取数据附近的一部分数据都读取进来，这样一次读取的一组数据就叫做CacheLine，每一级缓存中都能放很多的CacheLine，缓存行越大，局部空间效率越高,读取时间越慢!缓存行越小，局部空间效率越低，读取时间越快!
一个缓存行存储的字节是2的倍数。不同机器上,缓存行大小也不一样,通常来说为64字节。。
空间局部性原理：按块读取，程序局部性原理，可以提高效率，充分发挥总线CPU针脚等一次性读取更多数据的能力。

我们可以通过一个小程序来认识：缓存一致性。

public class day04 {
    public static long COUNT = 1000_0000_0000L;

    private static class T{
//        private long p1=1L,p2=1L,p3=1L,p4=1L,p5=1L,p6=1L,p7=1L;
        public long x = 0L;
//        private long p9=1L,p10=1L,p11=1L,p12=1L,p13=1L,p14=1L,p15=1L;
    }
    public static T[] arr = new T[2];
    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }
            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }
            latch.countDown();
        });
        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime()-start)/100_000L);
    }
}

当我们放开注释的两行代码时，会发现效率提升了。这就是由于缓存一致性所产生的现象。
在这里插入图片描述
但如果将注释放开，数据被进行了填充，则两条数据不可能位于统一缓存行，则会变成下列这种情况。

在这里插入图片描述
在Disruptor中也使用到过这种特点。
在这里插入图片描述

在这里插入图片描述

在JDK8中提供了一个注解：@Contended，被这个注解修饰的变量不会和其他数据处于同一缓存行，相当于自动为其填充了空白数据。使用时需要添加参数：-XX:-RestrictContended （但只有JDK1.8有）

MESI 是Cache一致性协议中的一种，是Inter的Cpu设计，比较有名。
在这里插入图片描述MESI协议是一个基于失效的缓存一致性协议，是支持写回（write-back）缓存的最常用协议。与写穿（write through）缓存相比，回写缓冲能节约大量带宽。总是有“脏”（dirty）状态表示缓存中的数据与主存中不同。MESI协议要求在缓存不命中（miss）且数据块在另一个缓存时，允许缓存到缓存的数据复制。与MSI协议相比，MESI协议减少了主存的事务数量。这极大改善了性能。

总结

本次学习，学习了，如何结束一个线程，以及并发编程三大特性之一的可见性。由此学习了volatile保障线程可见性，缓存行的概念和机制，以及大概了解了缓存一致性协议。

梦虬孙~
关注
专栏目录
多线程-day01.docx
12-12
在本教程中，我们将探讨多线程的基础知识，包括并发与并行的区别，进程与线程的概念，以及如何在 Java 中创建和管理线程。 并发与并行是两个经常混淆的概念。并发指的是多个任务在一段时间内交替执行，它们可能在...
线程知识学习三（线程的“打断”）
lsd&xql的博客
10-18 611
线程知识学习三（线程的“打断”）interrupt的三个方法 interrupt的三个方法 1、interrupt():打断某个线程（设置线程中断标志位） 2、isInterrupted():查询某个线程是否被打断过（查询中断标志位） 3、static interrupted():查询当前线程是否被打断过，并重置打断标志 public class Interrupt_and_isInterrupted { public static void main(String[] args) {
创建线程的六种状态代码示例
最新发布
m0_70299172的博客
05-21 188
RUNNABLE ： 可运行状态，由线程调度器可以安排执行。TIMED WAITING： 隔一段时间后自动唤醒。包括READY和RUNNING两种细分状态。NEW ： 线程刚刚创建，还没有启动。BLOCKED： 被阻塞，正在等待锁。TERMINATED： 线程结束。WAITING： 等待被唤醒。
JAVA多线程-(二)线程的生命周期和线程的“打断”
qq_37200262的博客
04-18 551
线程的生命周期 1.生命周期 一个线程从创建，到最终的消亡，需要经历多种不同的状态，而这些不同的线程状态，由始至终也构成了线程生命周期的不同阶段。线程的生命周期可以总结为下图。 其中，几个重要的状态如下所示。 NEW：初始状态，线程被构建，调用new Thread()，但是还没有调用start()方法。 RUNNABLE：可运行状态，可运行状态可以包括：运行中状态和就绪状态，就绪状态是调用了start()方法，但是没有获取CPU资源，等待获取CPU资源的状态，一旦获取了CPU资源线程调度器开始调度就会开始
多线程---多线程基础知识
热门推荐
意田天的博客
08-05 1万+
多线程基础知识2. 线程的基本概念2.1 启动线程的5中方法2.2 线程的状态2.2.1 JAVA的6种线程状态1. NEW2. RUNNABLE (RUNNING+READY)3. WAITING4. TIMED_WAITING5. BLOCKEDTERMINATED2.2 线程的打断2.2.1 interrupt的三个方法2.2.2 interrupt和sleep() wait() join()2.2.3 interrupt 是否能中断正在竞争锁的线程synchronized锁Lock锁如何打断锁竞争的
线程的状态
yw_2022的博客
03-15 358
线程的状态
多线程-day03.docx
12-12
【多线程-day03.docx】文档主要讨论了如何实现一个高效的秒杀系统，其中涉及到了多线程技术在高并发场景下的应用。以下是基于文档内容解析出的相关知识点： 1. **秒杀业务流程**： - 商家提交秒杀商品申请，包括...
python多线程DAY05.txt
04-27
多进程/多线程并发 ： 任何任务 3. 基于fork的多进程并发程序 每当有一个客户端连接就创建一个新的进程 4. ftp文件服务程序 *********************************************** 多线程并发 threading 的多...
python多线程DAY01.txt
04-27
1.epoll模型 ： 效率高 ， 触发方式更多 2.本地套接字 AF_UNIX 本地两个进程间的消息通信 3.多任务编程 * 并行 和 并发 * 进程 线程 4. 多进程编程 时间片 PCB PID 父子进程 优先级 进程特征 进程状态： 就绪态 ...
day14_多线程01.zip
09-12
总之，“day14_多线程01”这个资源可能涵盖了多线程的基本概念、创建与管理线程的方法、线程同步和安全、以及多线程在实际开发中的应用。学习多线程是提升编程技能的重要步骤，它能帮助开发者设计出更加高效、响应...
java线程的基本概念
橙子的随笔集
03-15 151
对java线程的基础概念进行讲解，并用demo验证了线程的创建、打断、结束和各种状态。
一、线程基本知识
Somous_的博客
11-05 457
一、计算机底层层面是逻辑图，然后再深刻理解：程序、进程、线程、纤程 进程（重）->线程（普通）->纤程（轻） 进程：是操作系统资源分配的基本单位，比如内存、打开文件、网络IO，分配了独立的内存空间 线程：是操作系统资源调度的基本单位，cpu分配的基本单位 纤程：是用户态的线程，是线程中的线程，切换和调度不需要经过OS(操作系统)。；轻量级的线程 - 线程 // 进程：是操作系统资源分配的基本单位，比如内存、打开文件、网络IO，分配了独立的内存空间 public class..
多线程面试题——哲学家就餐问题（Java）
How many ten years in the life time?
12-29 1937
哲学家就餐问题 公众号：小成同学在coding 文章如有问题欢迎指正 5名哲学家，5根筷子，哲学家左右两边的筷子跟身边的人共享，只有同时拿起左手的筷子和右手的筷子，哲学家才可以夹菜。 这个问题其实是一个死锁问题。 当0号拿着a筷子的时候，它需要申请b这根筷子，才可以夹菜，但b这根筷子在被1号使用着，因此0号无法夹菜，这时候怎么办，需要等1号吃完，把b筷子放手，而1号想夹菜则需要申请c这根筷子，但c这根筷子又被2号使用着，所以每名哲学家左手都拿着筷子，而右手的筷子都在被使用中，形成了一个死锁环。
JAVA多线程-(三)如何让线程暂停
qq_37200262的博客
04-19 2255
如何让线程暂停 stop方法 package com.juc.c_001_00_thread_end; import com.util.SleepHelper; public class T01_Stop { public static void main(String[] args) { Thread t = new Thread(() -> { while (true) { System.out.println("
多线程之线程状态
zy_crazy_code的博客
03-15 168
JAVA的6中线程状态 1. NEW ： 线程刚刚创建，还没有启动 2. RUNNABLE ： 可运行状态，由线程调度器可以安排执行 * 包括READY和RUNNING两种细分状态 3. WAITING： 等待被唤醒 4. TIMED WAITING： 隔一段时间后自动唤醒 5. BLOCKED： 被阻塞，正在等待锁 6. TERMINATED： 线程结束 package com.ex...
吃透这几道多线程面试题，进大厂也没你们想的那么难
m0_65618219的博客
12-22 275
就在前天我去阿里面试P7职位，面试官直接给我出了这六道多线程面试题，同步深刻思考问题，哲学家就餐问题、异步线程事务咋回滚问题、触及灵魂的同步问题、经典的线程交替问题、生产者消费者问题、下面就是我做出来的答案以及代码 Show Me The Difference (From Alibaba） package com.mashibing.juc.c_35_QuestionsOfAlibaba; public class ShowMeTheDifference {} //4.指出以下两段...
多线程--04--线程的生命周期
时光里的博客
11-12 416
线程的生命周期 public enum Stat{ } 内部内枚举类 线程生命周期，总共有五种状态： 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()； 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 运行状态（Running）：当CPU开始
线程知识学习二（创建线程的五种方式及线程的状态）
lsd&xql的博客
10-16 216
线程知识学习二（创建线程的五种方式及线程的状态）创建线程的五种方式线程的六种状态 创建线程的五种方式 1、继承Thread类（不建议使用，Java单继承，使用此方式不灵活） 2、实现Runnable接口 3、lambda表达式 4、使用ThreadPool（池子里面已经有线程，然后直接通过池子往外拿） 5、实现Callable接口（Runnable无返回值Callable有返回值） public class HowToCreateThread { static class MyThread exte
2021-04-12-并发编程三大特性
java_study_的博客
04-13 118
1、可见性（visibility） volatile保证线程可见性 /** * volatile 关键字，使一个变量在多个线程间可见 * A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道 * 使用volatile关键字，会让所有线程都会读到变量的修改值 * <p> * 在下面的代码中，running是存在于堆内存的t对象中 * 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程
秒杀系统设计与实现：多线程技术剖析
在本篇文档"多线程-day03"中，主要讨论了关于多线程编程在秒杀系统中的应用与实现。秒杀是一种常见的电子商务促销活动，涉及到快速销售有限数量的商品，通常设置库存和时间限制，对系统并发处理能力有较高要求。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值