两个线程交替打印奇偶数

最新推荐文章于 2024-08-30 10:01:15 发布
最新推荐文章于 2024-08-30 10:01:15 发布
阅读量3.1k 收藏 19
点赞数 4
分类专栏： 多线程 文章标签： 多线程 并发编程 java thread 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43568109/article/details/118570876
版权
本文介绍了使用Synchronized、Volatile、Semaphore和ReentrantLock四种方式实现两个线程交替打印1-10的解题思路和代码实现。每种方法都确保了线程间的正确同步，避免了竞态条件，实现了交替打印的目标。
摘要由CSDN通过智能技术生成

问题描述

设计两个线程，打印1-10，一个线程打印奇数，另一个线程打印偶数，要求交替打印。 最后输出123……10

方法一(Synchronized+共享变量)

1.解题思路

新建一个对象，并定义一个共享变量。只要flag不为1，线程t2就会阻塞，释放锁资源，所以t1线程先执行，此时flag为0，跳过while判断，然后修改flag为1，打印奇数，并唤醒t2，由于flag被改为1，下次循环，t1就会阻塞。t2被唤醒后，t1已经释放了锁资源，所以t2可以获取锁资源，并且flag为1，跳过while循环，修改flag为0，打印偶数，唤醒t1。

2.代码实现
public class Synchronized_Shared_Variable {

    static final Object obj = new Object();
    private static int flag = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                for (int i = 1; i <= 10; i += 2) {
                    while (flag != 0) {
                        try {
                            obj.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    flag = 1;
                    System.out.println(Thread.currentThread().getName() + "****" + i);
                    obj.notify();

                }
            }
        }, "线程t1");
        Thread t2 = new Thread(() -> {
            synchronized (obj) {
                for (int i = 2; i <= 10; i += 2) {
                    while (flag != 1) {
                        try {
                            obj.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    flag = 0;
                    System.out.println(Thread.currentThread().getName() + "****" + i);
                    obj.notify();
                }
            }
        }, "线程t2");
        t1.start();
        t2.start();
    }
}
3.测试

在这里插入图片描述

方法二(Volatile)

1.解题思路

定义一个volatile修饰的共享变量flag，当flag为false时，t2线程让出系统资源，自己进入就绪状态，让t1先执行，t1获取资源后，首先跳过while判断，打印奇数，修改flag为true，下次循环时，就会让出资源，此时t2从就绪状态进入执行状态，跳过while判断，打印偶数，修改flag为false，下次循环时，就会让出资源。如此不断交替执行，直到打印完所有奇数偶数。

2.代码实现
public class Volatile {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {

            for (int i = 1; i <= 10; i += 2) {
                while (flag) {
                    Thread.yield();
                }
                System.out.println(Thread.currentThread().getName() + "****" + i);
                flag = true;
            }

        }, "线程t1");
        Thread t2 = new Thread(() -> {

            for (int i = 2; i <= 10; i += 2) {
                while (!flag) {
                    Thread.yield();
                }
                System.out.println(Thread.currentThread().getName() + "****" + i);
                flag = false;
            }
        }, "线程t2");

        t1.start();
        t2.start();
    }
}
3.测试

在这里插入图片描述

方法三(Semaphore)

1.解题思路

定义两个信号量，一个许可为1，一个许可为0。首先许可为0的会阻塞，所以t1线程先执行，通过s1.acquire()消耗许可，打印奇数，此时s1许可为0，t1阻塞，同时s2.release()获得一个许可，t2线程通过s2.acquire()消耗许可，打印偶数，此时s2许可又变为0，t2阻塞，同时s1.release()获得一个许可。如此反复执行，直到打印完所有的数。

2.代码实现
public class Semaphore_Method {

    public static void main(String[] args) {
        Semaphore s1 = new Semaphore(1);
        Semaphore s2 = new Semaphore(0);
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 10; i += 2) {
                try {
                    s1.acquire();
                    System.out.println(Thread.currentThread().getName() + "****" + i);
                    s2.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }, "线程t1");
        Thread t2 = new Thread(() -> {
            for (int i = 2; i <= 10; i += 2) {
                try {
                    s2.acquire();
                    System.out.println(Thread.currentThread().getName() + "****" + i);
                    s1.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "线程t2");
        t1.start();
        t2.start();
    }
}
3.测试

在这里插入图片描述

方法四(ReentrantLock)

1.解题思路

首先定义一个lock和一个condition。当flag为false时，t2会阻塞，此时t1先执行，打印奇数，通过condition唤醒t2，修改flag为true，下次循环自己就会进入阻塞状态。t2被唤醒后，由于flag已经变为true，跳过while判断，打印偶数，唤醒t1，修改flag，自己阻塞，如此反复。

2.代码实现
public class ReentrantLock_Condition {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {

            for (int i = 1; i <= 10; i += 2) {
                lock.lock();
                while (flag) {
                    try {
                        condition.await();
                    } catch (Exception e) {

                    }
                }
                System.out.println(Thread.currentThread().getName() + "****" + i);
                condition.signal();
                flag = true;
                lock.unlock();
            }

        }, "线程t1");
        Thread t2 = new Thread(() -> {

            for (int i = 2; i <= 10; i += 2) {
                lock.lock();
                while (!flag) {
                    try {
                        condition.await();
                    } catch (Exception e) {

                    }
                }
                System.out.println(Thread.currentThread().getName() + "****" + i);
                condition.signal();
                flag = false;
                lock.unlock();
            }
        }, "线程t2");

        t1.start();
        t2.start();
    }
}
3.测试

在这里插入图片描述

方法五(阻塞队列)

1.解题思路

定义一个阻塞队列，t2线程调用put或tranfer往队列里放数据时，会阻塞，所以t1先执行，取走之前放进来的奇数，并打印，然后将偶数put或tranfer到队列，t1阻塞，t2继续执行，如此反复执行。

2.代码实现

SynchronousQueue实现：

public class Synchronous {

    public static void main(String[] args){
        int[] odd={1,3,5,7,9};
        int[] even={2,4,6,8,10};
        SynchronousQueue<Integer> queue=new SynchronousQueue<>();
        new Thread(()->{
            try{
                for(int i:even){
                    System.out.println(Thread.currentThread().getName() + "****"+queue.take());
                    queue.put(i);

                }
            }
            catch(Exception e){
                e.printStackTrace();
            }
        },"线程t1").start();
        new Thread(()->{
            try{
                for(int i:odd){
                    queue.put(i);
                    System.out.println(Thread.currentThread().getName() + "****"+queue.take());
                }
            }
            catch(Exception e){
                e.printStackTrace();
            }
        },"线程t2").start();
    }
}

TransferQueue实现：

public class Transfer {

    public static void main(String[] args){
        int[] odd={1,3,5,7,9};
        int[] even={2,4,6,8,10};
        TransferQueue<Integer> queue=new LinkedTransferQueue<>();
        new Thread(()->{
            try{
                for(int i:even){
                    System.out.println(Thread.currentThread().getName() + "****"+queue.take());
                    queue.transfer(i);

                }
            }
            catch(Exception e){
                e.printStackTrace();
            }
        },"线程t1").start();
        new Thread(()->{
            try{
                for(int i:odd){
                    queue.transfer(i);
                    System.out.println(Thread.currentThread().getName() + "****"+queue.take());
                }
            }
            catch(Exception e){
                e.printStackTrace();
            }
        },"线程t2").start();
    }
}
3.测试

在这里插入图片描述
在这里插入图片描述

xqxls1
关注
专栏目录
两个线程交替打印奇偶
皮皮狗
09-26 693
要求描述 两个线程，其中一个线程打印奇数，另外一个线程打印偶数。两个线程交替打印，输入1,2,3，...，100 基本思路 利用通知等待机制，第一个线程打印后，然后唤醒第二个线程，并释放锁。第二个线程执行同样的操作 代码实现 package basicKnowledge.thread; import java.util.concurrent.atomic.AtomicInt...
java两个线程交替打印_java两个线程交替打印奇偶数
weixin_33207144的博客
02-12 884
引言java面试中经常会遇到这个问题，如何用两个线程交替打印奇偶数。线程A打印1，线程B打印2，线程A打印3，线程B打印4...这个问题的解题思路是协调两个线程的执行时机，线程A与线程B需要交替执行。实现的方式很多，常用的方法是采用wait/notify方法。本文记录了笔者解决这个问题的过程，并解释过程中遇到的坑以及如何填坑的，以供朋友们参考。一种有问题的实现方式代码思路是这样的：既然要两个线程交...
多线程技术: 两个线程交替打印奇数和偶数
weixin_33981932的博客
10-29 413
转自：https://www.cnblogs.com/luozhijun/p/6895455.html 1. 要打印的资源 1 package com.mytest.thread; 2 3 /** 4 * 要打印的资源 5 * 6 */ 7 public class Num { 8 int i = 1; 9 // 两个线程看， 交替执行的一个标志 1...
Java 交替输出两个线程，打印0-100的奇偶数
最新发布
weixin_60690901的博客
08-30 768
当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。与wait()方法不同，执行notify()后，不会立即释放对象锁，而需要执行完synchronized的代码块或方法才会释放锁，所以接收通知的线程也不会立即获得锁，也需要等待执行notify()方法的线程释放锁后再获取锁。调用notify()方法后，会通知一个执行了wait()方法的阻塞等待线程，使该等待线程重新获得取到对象锁，然后继续执行wait()后面的代码。
两个线程交替打印奇数和偶数
赶路人儿
09-24 537
实现思路是使用锁来控制不同线程的执行。下面有两种实现： 1、使用对象监视器： public class OddEvenPrinter { private final Object monitor = new Object(); private final int limit; private volatile int count; public OddEvenPrinter(int limit, int initCount) { this.limit
打印out of memory while expanding_经典面试题——两个线程交替打印奇数和偶数
weixin_39829166的博客
11-24 195
前提今天下班时候和同事聊天偶然听到面试题“两个线程交替打印奇数和偶数”的实现，这里做一个复盘。复盘场景一：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用对象监视器实现。场景二：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用JDK提供的并发类库实现。这两个场景中，场景一是一种比较古老的同步方式，本质由JVM实现；场景二是JDK1.5引入JUC包之后简化了并发编程的前提下的...
线程篇 - 两个线程交替打印奇偶数
qq_43783527的博客
02-07 513
采用wait和notify的方式。 while的方式： package com.cms.cms.thread.依次打印; /** * Description: 使用等待唤醒机制打印奇数偶数 -- while循环的方式 * 注意： * 1.必须指明是object对象在调用notify和wait方法，不指明默认就是this-当前对象（那你代码肯定跑不起来） （i）我们锁的对象是object，monitor监视的是object对象，wait和notify都是object来调用啊。
两个线程交替打印奇数偶数的两种实现。
专注赚钱的程序员
03-13 5852
这是一个经典的java多线程面试题，今天分享一下实现交替打印的两种实现方式。 第一种： public class ThreadTest { public static void main(String[] args) { PrintNum p=new PrintNum(); Thread t1=new Thread(p); Thread t2...
C/C++语言实现两个线程交替打印奇偶数
码上得道的博客
06-30 4951
第一种方式 实现思想主要是让两个线程互相唤醒对方来交替打印数字 #include <unistd.h> #include <stdlib.h> #include <pthread.h> #include <stdio.h> int g_num = 1; pthread_mutex_t mutex; pthread_cond_t cond1,cond2; void* thread1(void* arg) { while(1) { pthread_
多种方法实现两个线程交替打印奇偶数
bruce_xia6116的博客
08-26 3093
交替打印奇偶数 问题描述： 构造两个线程，交替打印1-100之间的数字，其中线程1打印奇数，线程2打印偶数。 方式1：采用synchronized同步锁和wait，notify线程通信机制来实现。 public class jiaotidayinshuzi { public static void main(String[] args){ PrintNum p...
ReentrantLock实现多线程交替打印奇偶数
monkey-jie的博客
04-29 1998
关于ReentrantLock的实现原理，详见这篇：https://github.com/crossoverJie/JCSprout/blob/master/MD/ReentrantLock.md 用ReentrantLock实现交替打印奇偶数，就是开两个线程，一个打印奇数，一个用于打印偶数。 为什么要用ReentrantLock呢，因为这里交替打印（线程交替执行），需要对共享变量flag进行反复...
两个线程交替打印1-100之间的奇偶数
こ Noahっ的博客
12-12 817
实现一：synchronized关键字实现（缺点：效率低） 实现思路：让两个线程来争夺同一把锁，如果抢到锁只有满足自己的奇偶判定条件才打印（注：&方式判断奇偶更高效） public class Demo04_两个线程交替打印奇数_纯synchronized { private static Object lock = new Object(); private sta...
经典面试题——两个线程交替打印奇数和偶数
weixin_30823001的博客
07-02 2989
前提 今天下班时候和同事聊天偶然听到面试题“两个线程交替打印奇数和偶数”的实现，这里做一个复盘。 复盘 场景一：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用对象监视器实现。 场景二：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用JDK提供的并发类库实现。 这两个场景中，场景一是一种比较古老的同步方式，本质由JVM实现；场景二是JDK1.5引入JUC包之后简化了并发编...
Java两个线程交替打印奇偶数（两种方法对比）
热门推荐
五道口
10-31 1万+
我们将通过“两个线程交替打印100内的奇偶数”，来展示下`wait()`方法和`notify()`方法的用法和优点，当然要体现出优点，自然要通过对比不使用这两个方法实现同一功能的代码，通过这几篇文章的讲解，帮你彻底搞懂`wait()`方法和`notify()`方法的用法。
288-两个线程交替打印奇数偶数
LINZEYU666的博客
04-21 161
两个线程交替打印奇数偶数 #include <thread> #include <condition_variable> #include <mutex> #include <iostream> using namespace std; mutex mx;//定义互斥锁 condition_variable cv;//定义条件变量 int number = 0;//全局量，初始化为0 void thread_func1()//线程1 { unique
两个线程交替打印1-100的奇数和偶数
bobo1356的博客
12-05 8074
问题定义 启动a、b两个线程，由这两个线程打印出1到100共一百个数字。 要求： a线程打印1、3、5、7等奇数，b线程打印2、4、6、8等偶数。 依次串行打印，即打印完1之后，再打印2，然后是3、4、5…直到100，全部打印完成后，进程能正常结束。 解决思路 两个线程交替打印，就是要两个线程之间进行同步，走走停停。线程的同步可以使用Object类自带的wait和notify（或者notify...
多线程-两个线程交替打印奇数偶数
ZKP_CSDN的博客
04-17 491
开启两个线程，交替打印奇数和偶数
两个线程交替打印0～100的奇偶数
绅士jiejie的博客
03-01 567
用synchronized关键字实现 public class TestMain { //定义一个int变量 private static volatile int number = 0; //定义一个对象锁 private static final Object lock = new Object(); public static void ma...
LINUX双线程交替打印奇偶数
06-07
以下是使用 POSIX 线程库实现的 Linux 双线程交替打印奇偶数的示例代码： ```c #include #include pthread_mutex_t mutex = ...最后，我们使用 `pthread_join` 函数等待两个线程结束，并销毁互斥锁和条件变量。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值