线程常用方法通信2

最新推荐文章于 2024-11-06 09:46:16 发布
最新推荐文章于 2024-11-06 09:46:16 发布
阅读量95 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58725148/article/details/127155749
版权

1、 join()、Thread.yield()

ThreadTest t1 = new ThreadTest("A");
ThreadTest t2 = new ThreadTest("B");
t1.start();
t1.join();
t2.start();
先执行t1线程，再执行t2线程。

ThreadTest t1 = new ThreadTest("A");
ThreadTest t2 = new ThreadTest("B");
ThreadTest t3 = new ThreadTest("C");
t1.start();
t2.start();
t1.join();
t3.start();
	t1线程和t2线程交替执行，当t1线程执行完后开始t3线程，执行过程中和t2没有关系

	多次实验可以看出，主线程在t1.join()方法处停止，并需要等待A线程执行完毕后才会执行t3.start()，
然而，并不影响B线程的执行。因此，可以得出结论，t.join()方法只会使主线程进入等待池并等待t线程执行完毕
后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。

	thread.join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
	比如在线程B中调用了线程A的join()方法，直到线程A执行完毕后，才会继续执行线程B。
	t.join();  // 调用join()方法，等待线程t执行完毕
	t.join(1000);  // 调用t线程，等待时间是1000毫秒
	PS：join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用
自身的notifyAll方法，来释放所有的资源和锁。

public class Join1 {
    public static void main(String[] args) {
        var ex = new Join1();
        var t1 = new Thread(ex::work,"T1");
        var t2 = new Thread(ex::work,"T2");
        var t3 = new Thread(ex::work,"T3");
        var t4 = new Thread(ex::work,"T4");
        // 并行
        // t2 -> t3 串行执行
        // t1 -> t3 串行执行 先执行t1再执行t3
        t1.start();
        t2.start();
        try {
            t1.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        t3.start();
        try {
            t2.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        t4.start();

    }
    
    public static void test(String[] args) {
        var ex = new Join1();
        var t1 = new Thread(ex::work,"T1");
        var t2 = new Thread(ex::work,"T2");
        var t3 = new Thread(ex::work,"T3");
        var t4 = new Thread(ex::work,"T4");
        
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        t2.start();
    }

    void work(){
        String tn = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e){
                e.printStackTrace();
            }
            System.out.printf("%s = %d%n",tn,i);
        }
    }
}

Thread.yield()

	使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态李选择，也就
是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程再
下一次中不会执行到了。
	Java线程中有一个Thread.yield()方法，很多人翻译成线程让步。顾名思义，就是说当一个线程使用了这
个方法之后，它就会把自己CPU执行的时间让掉，让自己或者其他的线程运行。
	打个比方：现在很多人在排队上厕所，好不容易轮到这个人上厕所了，突然这个人说：“我要和大家来个
竞赛，看谁先抢到厕所！”，然后所有的人再同一起跑线冲向厕所，有可能是别人抢到了，也有可能他自己
抢到了。我们还知道县城有个优先级的问题，那么手里有优先权的这些人就一定能抢到厕所的位置吗？不
一定的，他们只是概率大些，也哟可能没特权的抢到了。

public class YieldTest extends Thread{
    public YieldTest(String name){
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("" + this.getName() + "-----" + i);
            // 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
            if (i == 30){
                this.yield();
            }
        }
    }

    public static void main(String[] args) {
        YieldTest yt1 = new YieldTest("张三");
        YieldTest yt2 = new YieldTest("李四");
        yt1.start();
        yt2.start();
    }
}

2、 interrupt()打断

------方法一

public class Interrupt1 {

    public static volatile boolean exit = false; // 退出标志

    public static void main(String[] args) {
        new Thread(){
            public void run(){
                System.out.println("线程启动了");
                while (!exit){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("线程结束了");
            }
        }.start();

        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        exit = true; // 5秒后更改退出标志的值，没有这段代码，线程就一直不能停止
    }
}

------方法二

public class Interrupt2 {
    public static void main(String[] args) {
        var t = new Thread(() -> {
            while (true){
                try {
                    System.out.println(Thread.currentThread());
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e){
                    // System.out.println(Thread.currentThread().getName() + "被中断了");
                    break;
                }
            }
        },"t1");
        t.start();

        try {
            System.out.println(Thread.currentThread());
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        t.interrupt();
    }
}

------方法三

public class Interrupt3 {
    public static void main(String[] args) {
        // 开启线程
        var t = new Thread(Interrupt3::work,"T1");
        t.start();

        try {
            TimeUnit.SECONDS.sleep(5);
            t.interrupt();
            System.out.println("线程是否被中断：" + t.isInterrupted()); // true
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void work(){
        Thread tt = Thread.currentThread();
        String tn = tt.getName();
        System.out.printf("%s启动了%n",tn);
        System.out.printf("%s.isInterrupted() %s%n",tn,tt.isInterrupted());
        while (!tt.isInterrupted()){
            System.out.printf("%s.isInterrupted() %s%n",tn,tt.isInterrupted());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e){
                break;
            }
        }
        System.out.printf("%s.isInterrupted() %s%n",tn,tt.isInterrupted());
        System.out.printf("%s结束了...%n",tn);
    }
}

public class Interrupt4 {

    final Object lock = new Object();

    public static void main(String[] args) {
        var t = new Interrupt4();
        for (int i = 0; i < 5; i++) new Thread(t::m,"T" + i).start();
        try {
            TimeUnit.SECONDS.sleep(5);
            synchronized (t.lock){
                // t.lock.notify();
                t.lock.notifyAll();
            }
        } catch (Exception e){
            e.printStackTrace();
        }

    }

    void m(){
        System.out.println(Thread.currentThread().getName() + "启动等待...");
        try {
            synchronized (lock){
                lock.wait(); // 进入阻塞状态
            }
            System.out.println(Thread.currentThread().getName() + "被唤醒了...");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

3、 原子工具类

	在jdk8之前，针对原子操作，我们基本上可以通过上面提供的这些类来完成我们多线程下的原子操作，
不过在并发高的情况下，上面这些单一的CAS + 自旋操作的性能将会是一个问题，所以上诉这些类一般
用于低并发操作。
	而针对这个问题，jdk8又引入了下面几个类：DoubleAdder，LongAdder，DoubleAccumulator，
LongAccumulator，这些类是对AtomicLong这些类的改进与增强，这些类都继承自Striped64这个类。

在这里插入图片描述

public class Atom1 {

    AtomicInteger n = new AtomicInteger(50);

    public static void main(String[] args) {
        var t = new Atom1();
        new Thread(t::minus,"T1").start();
        new Thread(t::minus,"T2").start();
        new Thread(t::minus,"T3").start();
        new Thread(t::minus,"T4").start();
        new Thread(t::minus,"T5").start();
        new Thread(t::minus,"T6").start();
        new Thread(t::minus,"T7").start();
        new Thread(t::minus,"T8").start();

    }

    int num = 50;
    void minus(){
        while (true){
            if (n.get() > 0){
                n.decrementAndGet(); // 相当于--i;
                System.out.printf("%s 售出一张票，剩余%d张票。%n",Thread.currentThread().getName(),n.get());
            } else {
                break;
            }
            /*
            if (num > 0){
                num --;
                System.out.printf("%s 售出一张票，剩余%d张票。%n",Thread.currentThread().getName(),num);
            } else {
                break;
            }
            */
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

public class Atom2 {

    AtomicBoolean flag = new AtomicBoolean(true);

    public static void main(String[] args) {
        var t = new Atom2();
        for (int i = 0; i < 5; i++) {
            new Thread(t::op,"T" + i).start();
        }

    }

    void op(){
        System.out.printf("%s 启动计算机中 %n",Thread.currentThread().getName());
        String[] o = new String[]{"","+","-"};
        Random rand = new Random();
        StringBuffer str = new StringBuffer("1");
        Pattern p = Pattern.compile("(\\d+|-\\d+)");
        while (flag.get()){
            for (int i = 2; i < 10; i++) {
                str.append(String.format("%s%d",o[rand.nextInt(o.length)],i));
                String s = str.toString(); // 123456789 = 100
                Matcher m = p.matcher(s);
                List<Integer> ln = new ArrayList<>();
                while (m.find()){
                    ln.add(Integer.parseInt(m.group()));
                }
                int sum = ln.stream().reduce(0,Integer::sum);
                if (sum == 100){
                    flag.set(false);
                    System.out.printf("[%s]:%s = 100%n",Thread.currentThread().getName(),s);
                    break;
                } else {
                    str.delete(1,str.length());
                }
            }
            System.out.printf("%s 结束 %n",Thread.currentThread().getName());
        }
    }
}

运行结果：98

public class Counter2 {

    public volatile static Integer count = 0;

    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch latch = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter2.inc();
                    latch.countDown();
                }
            }).start();
        }
        latch.await();
        System.out.println("运行结果：" + Counter2.count);

    }

    public synchronized static void inc(){
        try {
            Thread.sleep(1); // 延迟1毫秒
        }catch (InterruptedException e){  // catch住中断异常，防止程序中断
            e.printStackTrace();
        }
        count++;  // count值自加1
    }
}

运行结果：100
_自有天意
关注
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
本文将深入探讨Java中用于线程唤醒与阻塞的常用方法，以及它们在实际编程中的应用。 1. **线程的阻塞** - `wait()`: 这个方法属于`Object`类，当一个线程调用对象的`wait()`方法时，它会释放该对象的锁并进入等待...
【Java多线程】【Thread类及常见方法】
OTO233的博客
07-19 805
Thread类是 JVM用来管理线程的一个类，每个线程都有一个唯一的相关联的Thread对象；每个执行流需要一个对象描述，就是Thread类的对象，JVM讲这些Thread对象组织起来，用于线程调度，线程管理；
Python如何实现线程间通信
09-16
Python提供了多种方式来实现线程间通信，其中最常用且推荐的方法是使用`queue`模块。`queue`库中的`Queue`类提供了线程安全的数据结构，允许不同线程之间的数据传递。线程可以安全地向队列中添加数据（使用`put()`...
浅析iOS应用开发中线程间的通信与线程安全问题
01-04
线程间通信常用方法 代码如下: – (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait; – (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr with...
Linux下多线程间通信
09-14
互斥锁（pthread_mutex_lock/pthread_mutex_unlock）是一种常用的同步原语，用于保护临界区，即一段必须由单个线程执行的代码。当一个线程调用`pthread_mutex_lock`尝试获取锁时，如果锁当前未被其他线程持有，该...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 631
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1122
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 774
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 454
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 257
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1008
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
大数据新视界 -- 大数据大厂之 Impala 性能优化：解锁大数据分析的速度密码（上）（1/30）
【青云交】荣登原力全国前三，作者周榜前四，苏州均榜首，全网领军人物前列。
11-03 1015
本文围绕 Impala 性能优化展开，阐述其对大数据分析效率和企业决策的关键意义，剖析数据规模与复杂度、查询优化等挑战。介绍数据存储（分区、压缩）和查询（索引、语句重塑）优化策略，并通过电商和金融案例展示效果。对比 Impala 与 Hive、Spark SQL 的优劣，强调 Impala 在 OLAP 查询的优势。还介绍了可视化工具对优化的助力。鼓励读者分享 Impala 使用中的优化经验，同时预告下一篇将深入探讨数据存储分区相关内容。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 374
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 269
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
GEMM优化（待更新）
qq_62704693的博客
11-03 748
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
Java项目实战II基于Spring Boot的秒杀系统设计与实现（开发文档+数据库+源码）
2401_86524610的博客
11-03 465
在互联网电商蓬勃发展的今天，秒杀活动已成为各大电商平台吸引用户、提升销量的重要手段。然而，秒杀活动带来的瞬时高并发访问量对系统的性能和稳定性提出了严峻挑战。传统的系统架构往往难以承受如此巨大的压力，容易出现系统崩溃、数据不一致等问题。基于Spring Boot的秒杀系统，正是为了解决这些问题而设计的。该系统利用Spring Boot框架的简洁性、高效性和可扩展性，结合分布式架构、缓存技术、消息队列等先进技术，构建了一个能够应对高并发访问、保证数据一致性和系统稳定性的秒杀平台。
SpringBoot整合minio服务
weixin_74261199的博客
11-01 438
这里我选用的是JDK1.8 + SpringBoot2.3.12.RELEASE。
Flowable 注册全局事件监听器的几种方式
weixin_43841461的博客
11-01 933
Override// 执行自定义逻辑@Override@Override// 注册 TASK_CREATED 事件监听器});
【前端】JavaScript 方法速查大全-DOM、BOM、时间、处理JS原生问题（三）
最新发布
万物皆有灵
11-06 722
在现代Web开发中，JavaScript是不可或缺的编程语言。无论是前端开发还是后端服务，掌握JavaScript的各种方法和技巧都是每位开发者的必修课。本文将为您提供一个全面、系统的JavaScript方法参考，涵盖数组操作、对象处理、DOM与BOM接口、时间处理、解决JS原生问题、函数应用、正则表达式、数据格式转换、随机数生成、文本处理等众多方面。无论您是初学者还是资深开发者，这份速查大全都将成为您日常开发中的得力助手！💪。
java 多线程常用方法
02-23
Java中多线程常用的方法有以下几种： 1. 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法，在run()方法中定义线程要执行的任务。然后通过创建子类的对象，调用start()方法启动线程。 2. 实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值