java 两个线程轮流执行 五种方法

最新推荐文章于 2026-05-10 06:04:14 发布
原创 最新推荐文章于 2026-05-10 06:04:14 发布 · 4.8k 阅读 · 18 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #多线程
本文介绍了如何实现Java中两个线程轮流执行的任务，例如线程A存入数据，线程B取出数据，并保证顺序。文章通过五个示例详细讲解了使用`synchronized`修饰函数、`synchronized`代码块、`ReentrantLock+Condition`、`Unsafe`的CAS操作以及`AtomicInteger`的方法，分析了各种方法的效率和CPU压力差异，对于理解和实践多线程控制具有指导意义。

welcome to my blog

问题: 线程A向一个map中存数据, 然后线程B从map中取数据, 循环这个过程, 最终效果像: 线程A存入1, 线程B取出1, 线程A存入2, 线程B取出2, 线程A存入3, 线程B取出3… 直到线程A存入100, 线程B取出100

问题的要求非常像生产者消费者模式, 但是有个很大的区别, 那就是生产者的生产和消费者的消费没有顺序要求, 但是这道题要求线程A和线程B轮流执行
考察点: 如何让两个线程轮流执行
考察点: 如何让两个线程轮流执行
考察点: 如何让两个线程轮流执行

下面写了五个例子
前三个例子使用了阻塞+唤醒的思路, 涉及用户态和内核态的切换, 效率偏低, 但是CPU压力小
后两个例子使用了vaolatile+CAS, 不能操作时通过自旋进行等待, 更高效, 但是CPU压力大

方法一: 使用synchronized修饰函数
import java.util.HashMap;

public class Study {
    public static void main(String[] args) {
        MyTest test = new MyTest();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.put();
            }
        }.start();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.get();
            }
        }.start();
    }
}

class MyTest {
    HashMap<Integer, Integer> map = new HashMap<>();
    int i = 1;

    synchronized void put() {
        for (int k = 0; k < 100; k++) {
            map.put(i, i);
            System.out.println(Thread.currentThread().getName() + "  " + i);
            i++;
            this.notify(); //等待队列中只有一个线程, 所以不用使用notifyAll()
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");

    }

    synchronized void get() {
        for (int k = 0; k < 100; k++) {
            int cur = map.get(i - 1);
            System.out.println(Thread.currentThread().getName() + "  " + cur);
            this.notify();
            try {
                //最多等待1s, 等待1s后没被唤醒则自己醒过来
                //因为最后一次循环时, 当前方法让出CPU后, 再也不会被唤醒了
                this.wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}

/*
打印结果
...
Thread-0  97
Thread-1  97
Thread-0  98
Thread-1  98
Thread-0  99
Thread-1  99
Thread-0  100
Thread-1  100
Thread-0执行完毕
Thread-1执行完毕
*/
方法二: 使用synchronized代码块
import java.util.HashMap;

public class Study {
    public static void main(String[] args) {
        MyTest test = new MyTest();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.put();
            }
        }.start();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.get();
            }
        }.start();
    }
}

class MyTest {
    HashMap<Integer, Integer> map = new HashMap<>();
    int i = 1;

    void put(){
        synchronized (this){
            for(int k=0; k<100; k++){
                map.put(i,i);
                System.out.println(Thread.currentThread().getName() + "  " + i);
                i++;
                this.notify();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }

    void get(){
        synchronized (this){
            for(int k=0; k<100; k++){
                int cur = map.get(i-1);
                System.out.println(Thread.currentThread().getName() + "  " + cur);
                this.notify();
                try {
                    //最后一次wait()后, 不会被唤醒, 所以需要设置最长阻塞时间
                    this.wait(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}
/*
打印结果
...
Thread-0  97
Thread-1  97
Thread-0  98
Thread-1  98
Thread-0  99
Thread-1  99
Thread-0  100
Thread-1  100
Thread-0执行完毕
Thread-1执行完毕
*/
方法三: 使用ReentrantLock+Condition; 因为synchronized能实现的功能ReentrantLock也能实现

起初想使用ReentrantLock的公平锁模式, 按照线程进入AQS等待队列的顺序获取锁, 这样就不用Condition了, 不过运行时有问题, 线程A启动后, 执行了好几次循环, 线程B才开始执行, 这样就没法保证轮流执行了

使用注意事项: Condition的signal(), signalAll(), await()方法必须在ReentrantLock的lock()和unlock()之间使用，否则报错:IllegalMonitorStateException，这跟wait(), notify(), notifyAll()一定要在synchronized块内执行是一样的

import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Study {
    public static void main(String[] args) {
        MyTest test = new MyTest();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.put();
            }
        }.start();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.get();
            }
        }.start();
    }
}

class MyTest {
    HashMap<Integer, Integer> map = new HashMap<>();
    int i = 1;

    ReentrantLock lock = new ReentrantLock();
    Condition con = lock.newCondition();

    void put() {
        for (int k = 0; k < 100; k++) {
            try {
                lock.lock();
                map.put(i, i);
                System.out.println(Thread.currentThread().getName() + "  " + i);
                i++;
                con.signal();
                try {
                    con.await(); //让出锁, 但是state应该不变, state应该由lock控制, 并不是con来控制
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                lock.unlock();
            }

        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }

    void get() {
        for (int k = 0; k < 100; k++) {
            try {
                lock.lock();
                int cur = map.get(i - 1);
                System.out.println(Thread.currentThread().getName() + "  " + cur);
                con.signal();
                try {
	                //最后一次让出锁后, 无法被唤醒, 所以需要定时
                    con.await(1000, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                lock.unlock();
            }

        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}

/*
Thread-0  97
Thread-1  97
Thread-0  98
Thread-1  98
Thread-0  99
Thread-1  99
Thread-0  100
Thread-0执行完毕
Thread-1  100
Thread-1执行完毕

Process finished with exit code 0

*/
方法四: 使用Unsafe类的CAS操作, 不能操作时便自旋; 不涉及线程的阻塞与唤醒, 更高效
import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Study {
    public static void main(String[] args) {
        MyTest test = new MyTest();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.put();
            }
        }.start();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.get();
            }
        }.start();
    }
}

class MyTest {
    HashMap<Integer, Integer> map = new HashMap<>();
    int i = 1;
    //使用volatile保证flag在两个线程中的可见性
    volatile int flag = 0; //0表示线程0可以执行, 1表示线程1可以执行
//    private static final Unsafe unsafe = Unsafe.getUnsafe(); //直接这么用会报错
    private static final Unsafe unsafe;
    private static final long flagOffset;


    //此处, try catch必须放到代码块中!
    static {
        try {
            unsafe = getUnsafeInstance();
            //获取flag的偏移量, 为CAS操作做准备
            //getDeclaredField()与getField
            flagOffset = unsafe.objectFieldOffset(MyTest.class.getDeclaredField("flag"));
        } catch (NoSuchFieldException e) {
//            throw new Error(e);
            throw new RuntimeException("初始化flagOffset失败");
        }catch(Exception e){
            throw new RuntimeException("初始化unsafe失败");
        }
    }

    //获取unsafe实例
    public static Unsafe getUnsafeInstance() throws Exception {
        // 通过反射获取rt.jar下的Unsafe类
        Field theUnsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeInstance.setAccessible(true);
        // return (Unsafe) theUnsafeInstance.get(null);是等价的
        return (Unsafe) theUnsafeInstance.get(Unsafe.class);
    }

    void put() {
        for (int k = 0; k < 100; k++) {
            //自旋; 等待flag为true
            for(;;){
                if(flag==0){
                    break;
                }
            }
            map.put(i, i);
            System.out.println(Thread.currentThread().getName() + "  " + i);
            i++;
            int tmp = flag;
            //使用CAS赋值
            unsafe.compareAndSwapInt(this, flagOffset, tmp, 1);
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }

    void get() {
        for (int k = 0; k < 100; k++) {
            for(;;){
                if(flag==1){
                    break;
                }
            }
            int cur = map.get(i - 1);
            System.out.println(Thread.currentThread().getName() + "  " + cur);
            int tmp = flag;
            unsafe.compareAndSwapInt(this, flagOffset, tmp, 0);
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}
/*
打印结果
...
Thread-0  97
Thread-1  97
Thread-0  98
Thread-1  98
Thread-0  99
Thread-1  99
Thread-0  100
Thread-1  100
Thread-0执行完毕
Thread-1执行完毕
*/
方法五: 使用AtomicInteger; 不能操作时便自旋
import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Study {
    public static void main(String[] args) {
        MyTest test = new MyTest();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.put();
            }
        }.start();

        //充当线程A的角色
        new Thread() {
            @Override
            public void run() {
                test.get();
            }
        }.start();
    }
}

class MyTest {
    HashMap<Integer, Integer> map = new HashMap<>();
    int i = 1;
    AtomicInteger flag = new AtomicInteger(0);//0表示线程0可以执行, 1表示线程1可以执行

    void put() {
        for(int k=0; k<100; k++){
            //自旋
            for(;;){
                if((flag.intValue()&1)==0){
                    break;
                }
            }
            map.put(i,i);
            System.out.println(Thread.currentThread().getName() + "  " + i);
            i++;
            flag.compareAndSet(flag.intValue(), 1);
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }

    void get() {
        for(int k=0; k<100; k++){
            //自旋
            for(;;){
                if((flag.intValue()&1)==1){
                    break;
                }
            }
            int cur = map.get(i-1);
            System.out.println(Thread.currentThread().getName() + "  " + cur);
            flag.compareAndSet(flag.intValue(), 0);
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}

/*
执行结果
...
Thread-1  97
Thread-0  98
Thread-1  98
Thread-0  99
Thread-1  99
Thread-0  100
Thread-1  100
Thread-1执行完毕
Thread-0执行完毕
*/
原线程创建两个新线程，实现两个新线程轮流计数的功能
quhongjuan12的博客
06-09 1389
编程要求：原线程创建两个新线程，实现两个新线程轮流计数的功能。 使用互斥锁完成两个子线程交替计数 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<pthread.h> pthread_mutex_t m; int flag;int count; void *tfn1(void *arg); void *tfn2(void *arg); void err_thread(int
Linux基础：多线程
weixin_58368590的博客
06-12 507
多线程相关问题以及处理方法
RT-Thread点灯背后的硬件原理：从电路图到代码，手把手分析STM32F103的PF9引脚驱动逻辑
最新发布
weixin_30338481的博客
05-10 615
本文深入解析了RT-Thread在STM32F103开发板上通过PF9引脚驱动LED的硬件原理与软件实现。从电路设计、寄存器操作到RT-Thread的硬件抽象层封装，详细展示了嵌入式开发中硬件与软件的协同工作。文章还提供了调试技巧和性能优化建议，帮助开发者深入理解LED驱动背后的技术细节。
两个线程，轮流有序执行的两种方法
qq_33881799的博客
11-22 4006
两个线程的任务都是打印1到1000的数据，要求线程1打印一次后线程2继续打印，实现轮流打印方法1：使用interrupt()和sleep()协调使用，一个打印完成后sleep(),并且interrupt另一个线程的睡眠，同时让自己睡眠，循环1000次即可方法2：通过公共锁object，配合wait()和notify()/notifyAll()方法，睡眠自己，唤醒另一线程，循环1000次public
Linux多线程（下）
Enthusiastic_boy的博客
05-06 1591
线程安全（下） 现在来一小段代码，来演示一下多个线程访问临界资源时保证合理性。假如有两个工作线程，一个工作线程做面，一个工作线程吃面，我们来约定一个规则：1.同一时刻吃面线程去吃面的时候，做面线程不能去做面，反之亦是这样，也就是保证互斥。2.没有面时，吃面线程不能去吃面，有面时，做面线程不能去做面，也就是保证面的数量只能是1或者0（合理访问临界区资源）。代码如下： 1 #include <stdio.h> 2 #include <pthread.h> 3
实验 Linux多线程编程
DQA1505045218的博客
07-05 1407
实验 Linux多线程编程 实验内容 1、创建两个线程，实现两个线程轮流数数的功能。 2、问题描述：假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。请用Linux多线程编程解决。 3、有50个读线程和50个写线程共同读、写文件，要求：(1)允许多个reader同时读一个文件
面试热点详解 —— 三个线程轮流打印
战斧的博客
05-04 1282
面试热点，三个线程轮流打印
实现三个线程轮流执行顺序打印ABC
Bobo‘s Home
06-16 1万+
这道题目在多线程的面试题中可能遇到的比较多，由于最近一直在学习Java多线程编程的知识，这里做一个总结，总结的可能并不是很全面，有问题或者有更好的编程方法也欢迎大家指出。 这道题目的实现方式很多，这里就以我了解的进行一个总结。 首先，我们看一下题目： 有三个线程A、B、C，采用多线程的方式使三个线程轮流执行顺序打印ABC 10次，结果如下： 通过wait/notify实现 package tes...
Java多线程之两个线程轮流打印
weixin_38107316的博客
07-27 2016
写在前面 在整个Java多线程中，线程轮流进行某种操作可以说是非常常见的一种场景，下面以一道实际的场景题为例，进行总结记录。 场景需求 两个线程轮流打印内容： 线程A：A 线程B：1 线程A：B 线程B：2 线程A：C 线程B：3 不多bb，上代码 import java.util.ArrayList; /** * 多线程循环打印1A 2B 3C */ public class testThread { // 用一个全局变量实现轮流输出的标志位 private static volat
Java 有两个任务A与B，多线程执行任务A完成后再继续执行任务B
热门推荐
guochao6531的博客
09-24 1万+
内容描述：在多线程中，有两个任务A与B，多线程执行任务A完成后再继续执行任务B，想到的两种方法一种线程间通信，使用条件变量方式，第二种就是使用CountDownLatch。 条件变量主要使用的条件变量，判断是否任务Ａ已经做完，然后再执行任务Ｂ public class Main { public static boolean[] flag = new boolean[3]; public
java怎么让两个线程轮流执行一次_两个线程，交替执行
weixin_35960357的博客
02-28 690
import java.util.*;public classMain {static ArrayList list=new ArrayList();private static Object lock=newObject();private static int a=1;private static int b=1;static boolean bool=true;public static v...
java 同一个线程_Java多线程处理同一个资源时，线程几乎不交替运行
weixin_34234983的博客
02-16 336
Java学习中，目前在看多线程所调试的例题是经典的多点售票程序为了防止售票点因为资源不同步的原因，而卖出超过实际票数的票则使用了synchronized关键字结果的确不会再卖出-1票了但是调试结果貌似不太理想，如果票数少，就基本上是第一个售票点卖完了即便票数多(100张)，线程也不是交替运行，而是一时全A，一时全B请帮忙查看代码是否有错，逻辑是否合理谢谢！代码：class Test24_04 im...
面试官问我怎么实现多个线程顺序执行，我一连说5种方法！
fager漫长路
06-30 3379
join是最基本 的，JUC下的能多一个是一个
Java多个线程顺序循环执行的几种实现方式
小马快跑的博客
07-21 7063
文章目录ReentrantLock+Condition方式实现Synchronized+wait/notifyAll方式实现两者对比 ReentrantLock+Condition方式实现 public class ReentrantLock_Impl { private static final String FLAG_THREAD_1 = "ReentrantLock_Thread1"; private static final String FLAG_THREAD_2 = "Reen
java 多个线程按顺序交替执行
weixin_49131718的博客
12-18 671
CountDownLatch使用一个计数器，调用await()方法计数器+1,调用countDown()方法计数器-1，当计数器为0时，使用await()方法的线程可以继续运行。join主要是让父线程等待子线程结束之后父线程才能继续运行。
java 多线程按顺序执行、顺序获取结果
T-bright的博客
12-10 6886
文章目录1、通过Thread的join方法2、FutureTask3、CountDownLatch（倒计数）4、wait、notify5、Condition(条件变量)6、CyclicBarrier(回环栅栏)5、线程池5.1、单线程化线程池5.2、多线程化线程池 1、通过Thread的join方法 join主要是让父线程等待子线程结束之后父线程才能继续运行 public static void main(String[] args) throws InterruptedException {
[实践总结] 如何设置2个线程执行顺序
张紫娃的博客
05-22 942
如果这样写的话线程one和线程two是交替执行的，但是不一定谁先启动。以上只是保证，线程one比线程two先开始执行，但是后面就开始争抢资源不一定谁先结束。这样就太给线程two特权了，线程two不执行完，线程one就一直等着！！！
两个线程轮流查数
weixin_30500473的博客
10-11 458
军训时最常见的莫过于报数了，1、2、3、4、5..... 现在我要用Java的多线程实现类似军训报数的功能， 即开启两个线程，让它们轮流数数，从1数到10，如： 线程A：1 线程B：2 线程A：3 线程B：4 线程A：5 线程B：6 ...... 如何实现该功能呢？ -------------------------------------------------------...
C++ 11多线程编程：2个线程轮流输出 字母和数字。
qd1006739486的博客
06-29 1030
c++ 11 多线程 轮流输出 字母和数字
java 双线程交替,Java 创建两个线程，和主线程交替运行。
weixin_42491590的博客
03-20 440
原来线程都有自己默认的名称。Thread-编号 该编号从0开始。static Thread currentThread():获取当前线程对象。getName(): 获取线程名称。设置线程名称：setName或者构造函数。class Test extends Thread{//private String name;Test(String name){//this.name = name;super...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值