多线程JUC 第2季 控制线程的执行顺序，依次，交替，同时

原创 已于 2024-12-13 14:25:53 修改 · 328 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #算法

于 2024-12-04 23:32:11 首次发布

目录

一 场景1 交替执行

1.1 方案1使用completablefuture

1.2 方案2 使用sycnchronized+wait+notify

二 场景2 同时执行

2.1 使用countdownlatch

三 场景3 顺序执行

3.1 使用join

3.2 使用join

3.3 使用单例线程池

3.4 使用单例线线程

一 场景1 交替执行

1.1 方案1使用completablefuture

1.代码

package com.ljf.thread.jiaoti;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName: main
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/12/10 20:25:15 
 * @Version: V1.0
 **/
public class JTctf {
    public static void main(String[] args) {
        for (int k=1;k<10;k++) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {

                    System.out.println("我是线程t1");

                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t1.join();
                        System.out.println("我是线程t2");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t2.join();
                        System.out.println("我是线程t3");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {
                t1.start();
            }).thenRun(() -> {
                        t2.start();
                    }
            ).thenRun(() -> {
                t3.start();
            });
        }
    }
}

2.结果：

1.2 方案2 使用sycnchronized+wait+notify

1.代码

package com.ljf.thread.jiaoti;

/**
 * @ClassName: JT
 * @Description: https://blog.51cto.com/mouday/11443720
 * @Author: admin
 * @Date: 2024/12/10 20:08:40 
 * @Version: V1.0
 **/
public class JT {
    private static  String flag="A";
    private static Object obj =new Object();
    public static void main(String args[]){
        for (int k=1;k<10;k++) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (obj) {
                        while (!"A".equals(flag)) {//不等于A时
                            try {
                             //   System.out.println("不等于A时，当前线程:" + Thread.currentThread().getName() + " 等待....");
                                obj.wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        //等于A时
                        System.out.println("线程A...");
                        flag = "B";
                        obj.notifyAll();
                    }
                }
            });

            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (obj) {
                        while (!"B".equals(flag)) {//不等于B时
                            try {
                             //   System.out.println("不等于B时，当前线程:" + Thread.currentThread().getName() + " 等待....");
                                obj.wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        //等于A时
                        System.out.println("线程B...");
                        flag = "C";
                        obj.notifyAll();
                    }
                }
            });

            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (obj) {
                        while (!"C".equals(flag)) {//不等于C时
                            try {
                               // System.out.println("不等于C时，当前线程:" + Thread.currentThread().getName() + " 等待....");
                                obj.wait();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        //等于C时
                        System.out.println("线程C...");
                        flag = "A";
                        obj.notifyAll();
                    }
                }
            });

            t1.start();
            t2.start();
            t3.start();
//System.out.println("====");
        }

    }
}

2.结果

二 场景2 同时执行

2.1 使用countdownlatch

1.代码

package com.ljf.thread.tongshi;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName: TS
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/12/10 20:38:54 
 * @Version: V1.0
 **/
public class TS {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ExecutorService  es = Executors.newCachedThreadPool();

        es.submit(()->{
            try {
                countDownLatch.await();
                System.out.println("线程A"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        es.submit(()->{
            try {
                countDownLatch.await();
                System.out.println("线程B"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        es.submit(()->{
            try {
                countDownLatch.await();
                System.out.println("线程C"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        countDownLatch.countDown();
        es.shutdown();
    }
}

2.结果

三 场景3 顺序执行

3.1 使用join

1.代码

package com.ljf.thread.shunxu;

/**
 * @ClassName: JtJoin
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/12/10 17:11:36 
 * @Version: V1.0
 **/
public class SxJoin {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                System.out.println("我是线程t1");

            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t1.join();
                    System.out.println("我是线程t2");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    t2.join();
                    System.out.println("我是线程t3");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();

    }
}

2.执行结果

3.2 使用countdownlatch

1.代码

package com.ljf.thread.shunxu;

import java.util.concurrent.CountDownLatch;

/**
 * @ClassName: SxCountD
 * @Description:  https://mp.weixin.qq.com/s/ply78SKIiA0Ru0CzYqlWrQ
 * @Author: admin
 * @Date: 2024/12/10 19:41:16 
 * @Version: V1.0
 **/
public class SxCountD {
    public static void main(String[] args) {
        CountDownLatch cd1 = new CountDownLatch(0);
        CountDownLatch cd2 = new CountDownLatch(1);
        CountDownLatch cd3 = new CountDownLatch(1);
        Thread t1 = new Thread(new Work(cd1,cd2),"t1");
        Thread t2 = new Thread(new Work(cd2,cd3),"t2");
        Thread t3 = new Thread(new Work(cd3,cd3),"t3");
        t1.start();
        t2.start();
        t3.start();
    }
}


public class Work implements Runnable{
  CountDownLatch ct1;
  CountDownLatch ct2;

    public Work(CountDownLatch ct1, CountDownLatch ct2) {
        this.ct1 = ct1;
        this.ct2 = ct2;
    }

    @Override
    public void run() {
        try {
            ct1.await();
            System.out.println("线程："+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        finally {
            ct2.countDown();
        }
    }
}

2.结果

3.3 使用单例线程池

1.代码

package com.ljf.thread.shunxu;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName: JtSchedule
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/12/10 17:19:35 
 * @Version: V1.0
 **/
public class SxSchedule {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                System.out.println("我是线程t1");

            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                    System.out.println("我是线程t2");

            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                    System.out.println("我是线程t3");

            }
        });
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(t1);
        executorService.submit(t2);
        executorService.submit(t3);
        executorService.shutdown();
    }
}

2.执行结果

3.4 使用单例线程池

1.代码

package com.ljf.thread.shunxu;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName: SxCompletefutureable
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/12/10 17:27:24 
 * @Version: V1.0
 **/
public class SxCompletefutureable {
    public static void main(String[] args) {
        for (int k = 1; k < 10; k++) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {

                    System.out.println("我是线程t1");

                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t1.join();
                        System.out.println("我是线程t2");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        t2.join();
                        System.out.println("我是线程t3");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            CompletableFuture ct1 = CompletableFuture.runAsync(() -> {
                t1.start();
            });
            ct1.thenRun(() -> {
                t2.start();
            }).thenRun(() -> {

                t3.start();
            });
        }
    }
}

 2.结果

Java并发编程——同步模式之顺序控制——juc多个线程交替打印
qq_51978342的博客
11-09 288
同时三个线程启动分别打印a、b、c， 要求按照循序打印abcabcabc。使用wait notify两个关键字实现。
多线程JUC 第2季 synchronized锁升级过程
健康平安的活着的专栏
09-13 268
1.结构： 前两行为8字节；后一行为类型指针4字节。2.读取流程3.结论：无锁状态，一个对象被实例化后，如果还没有被任何线程竞争锁，那么它为无锁状态(001)三 偏向锁3.1。
JUC多线程
最新发布
weixin_52634451的博客
06-03 838
得此章，JUC可结
Java多线程，JUC学习
qq_40088655的博客
12-19 668
多线程 CAS(compare and swap, compare and exchange) 保证在没有锁的状态下，多线程下保持一一致性实现值的改变。 ABA问题：分手，找别人，复合；中间的经历无法感知。 AtomicInteger JUC JUC是java.util.concurrent工具包的简称，这是一个处理线程的工具包，从JDK1.5开始出现。 进程与线程 进程Process：是系统进行资源分配和调度的基本单位，是操作系统结构的技术。进程是线程的容器，程序是指令、数据及组织形式的描述，进程是程序
JUC多线程学习笔记
m0_51028853的博客
04-06 746
多线程 一. 线程;进程;多线程 普通方法调用和多线程 程序->进程->线程 在操作系统中运行的程序就是进程,比如你的电脑可以同时打开QQ,播放器,游戏,IDEA等等. 一个进程可以有多个线程,比如视频可以同时听声音,看图像,看弹幕,看字母,等等. 说起进程就不得不说下程序,程序时指令和数据的有序集合,本身没有任何运行的涵义,是一个静态的概念,而进程是执行程序的一次执行过程,它是一个动态的概念.是系统资源分配的单位. 通常在一个进程中可以包含若干线程,当然一个进程中至少有一个线程,不然
Java：多线程和JUC详解
游手好闲
01-06 3421
Java多线程和JUC详解
【JUC】多线程交替、循环、顺序打印问题？
时光、疏离了记忆づ童话的博客
06-06 531
文章目录方式一、Lock锁实现方式二、利用Synchronized锁实现方式三、利用Lock锁的Condition精准唤醒线程实现方式四、协同型打印 3个线程依次打印1、2、3…这个问题，常常被作为面试题，题目如下： 三个线程，一个线程负责打印1，4，7，……；第二个负责打印2，5，8，……，第三个负责打印3，6，9，……，要求在控制台中按顺序输出1，2，3，4，5，6……。 事实上，这道题被作为了腾讯二面的一道题，如果没有复习过相关的知识，在面试中可能写出来千奇百怪。不过，这个题实现方式多种多样，如何
JAVA社交平台项目第七天 JUC多线程
fegus的博客
04-23 561
JUC多线程 (一) 学习目标： 掌握多线程的创建 掌握线程安全的处理 了解线程状态 掌握线程停止的两种方法 了解线程的原子性，可见性和有序性 理解内存可见性的原理 掌握synchronized解决内存可见性 1. 多线程基础 一个采用了多线程技术的应用程序可以更好地利用系统资源。其主要优势在于充分利用了CPU的空闲时间片，可以用尽可能少的时间来对用户的要求做出响应，使得进程的整体运行效率得到较大提高，同时增强了应用程序的灵活性。 更为重要的是，由于同一进程的所有线程是共享同一内存，所以不需要特殊的数据
JUC笔记(一)多线程的认识
-
03-18 905
JUC是java.uitl.concurrent包下的一系列的的并发编程的包。 线程和进程 线程 在操作系统中，线程是比进程更小的能够独立运行的基本单位。同时，它也是CPU调度的基本单位。线程本身基本上不拥有系统资源，只是拥有一些在运行时需要用到的系统资源，例如程序计数器，寄存器和Java虚拟机栈等。一个进程中的所有线程可以共享进程中的所有资源。 线程与进程相似，但线程是一个比进程更小的...
JUC多线程学习个人笔记
07-08
JUC还包含了一些并发编程的实用工具，如Semaphore（信号量，用于限制同时访问某个资源的线程数量），CountDownLatch（计数下标，用于等待一组线程完成任务），CyclicBarrier（循环栅栏，使一组线程等待其他线程到达...
JAVA线程高级-线程按序交替执行
11-01
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了系统的效率和响应性。然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程...
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
多线程中线程池常见7个参数的详解以及执行流程
健康平安的活着的专栏
08-08 7200
一 线程池常见参数 1.1 概念 1.2 coresize和maxsize，poolsize 1.corePoolSize： 线程池的基本大小，即在没有任务需要执行的时候线程池的大小，并且只有在工作队列满了的情况下才会创建超出这个数量的线程。 2.maximumPoolSize： 线程池中允许的最大线程数 3.poolSize： 线程池中当前线程的数量 3者之间的关系： 新提交一个任务时的处理流程很明显： 1、如果当前线程池的线程数还没有达到基本大小(poolSize ..
有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…
健康平安的活着的专栏
01-27 5685
题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…  方法一：使用lock和condition来实现a执行完通知b执行，b执行完通知c执行，c执行完通知a执行的顺序，使用Executors的fixedthreadpool，将三个线程放到线程池里面，使用线程池控制程序的结束，调用shutdown（）方法。 package com.ljf.thread....
线程池的执行流程
健康平安的活着的专栏
02-14 3747
列举一个线程池max=6,core=3，任务队列taskQueue=5;采用饱和策略为1） 则我们看看提交任务给此线程池的执行逻辑如下： 1）首先我们提交第一个任务到线程池，此时核心线程数都还没有用，所以会启动核心线程之一来执行任务 2）接着提交第二个第三个任务到线程池，他们的执行逻辑同第一个任务是一模一样的，线程池会启动核心线程池中剩下的两个线程来执行你新提交的任务。 3）接着又有新的任...
java中Timer和Timertask的关系
健康平安的活着的专栏
03-02 2456
1.Timer来讲就是一个调度器,而TimerTask呢只是一个实现了run方法的一个类；2.Timer和TimerTask成对出现，Timer是定时器，TimerTask是定时任务。换句话说，定时任务TimerTask是给定时器Timer执行的具体任务。TimerTask实现Runnable接口的run方法。3.每一个Timer仅对应唯一一个线程。Timer不保证任务执行的十分精确。Timer类的线程安全的。
java中yield 和join的作用
健康平安的活着的专栏
01-20 1627
1.yeild作用：当前线程从运行状态变为可执行状态，放弃当前cpu的资源，将它让给其他任务，包括自己，去占用cpu的执行时间，放弃的时间不确定，有可能刚刚放弃，马上又获得cpu的时间片。 只能使同优先级或者高优先级的线程得到执行机会。 cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。 2...
使用countdownlatch和线程池fixedThreadPool实现任务的分发执行
健康平安的活着的专栏
01-07 1550
业务逻辑要求：每次调用多个任务，将任务分发给多个子线程，实现并行执行。本代码使用缓存线程池cacheThreadPool初始化多个线程，使用countdownlatch做子线程的计数控制，当子线程执行完，释放执行权，交给主线程，开始下一轮的执行。 话不多说：上代码 package com.test.thread; import java.util.ArrayList; import jav...
多线程JUC 第2季 wait和notify唤醒机制
健康平安的活着的专栏
03-17 919
1) 使用wait()、notify()和notifyAII()时需要先对调用对象加锁。否则直接调用的话会抛出 IllegalMonitorStateExceptiona。2) 调用wait()方法后，线程状态。由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。3) notify()或notifyAlI()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAII()的线程释放锁之后，等待线程才有机会从wait()返回。
Java并发编程详解：JUC工具包与多线程实战
并发是指在一段时间内，多个任务看似同时执行，实际上可能是交替执行；而并行则是指多个任务在同一时刻真正地同时执行。并发通常发生在单CPU系统中，依赖于操作系统的调度，而并行则发生在多CPU或多核系统中，每个...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值