专栏首页云扬四海面试题-使用线程交替打印奇数偶数

面试题-使用线程交替打印奇数偶数

这世上有三样东西是别人抢不走的:一是吃进胃里的食物,二是藏在心中的梦想,三是读进大脑的书

  • 分析题目。需要使用两个线程交替打印奇偶数。
    • 使用同步锁解决这个问题
    • 使用信号量来实现交替打印
  • 定义两个信号量,一个奇数信号量,一个偶数信号量,都初始化为1
  • 先用掉偶数的信号量,因为要让奇数先启动,等奇数打印完再释放

信号量实现

  • 具体实现思路:
    • 定义两个信号量,一个奇数信号量,一个偶数信号量,都初始化为1
    • 先用掉偶数的信号量,因为要让奇数先启动,等奇数打印完再释放
    • 具体流程就是 第一次的时候先减掉偶数的信号量 奇数线程打印完成以后用掉奇数的信号量。然后释放偶数的信号量如此循环
import java.util.concurrent.Semaphore;

/**
 * @ClassName AlternatePrinting
 * @Author yunlogn
 * @Date 2019/5/21 
 * @Description 交替打印奇偶数
 */
public class AlternatePrinting {

    static int i = 0;
    public static void main(String[] args) throws InterruptedException {

      Semaphore semaphoreOdd = new Semaphore(1);
         Semaphore semaphoreEven = new Semaphore(1);

      semaphoreOdd.acquire();  //让奇数先等待启动,所以先减掉偶数的信号量 等奇数线程来释放

        SemaphorePrintEven semaphorePrintEven = new SemaphorePrintEven(semaphoreOdd, semaphoreEven);
        Thread t1 = new Thread(semaphorePrintEven);
        t1.start();

        SemaphorePrintOdd semaphorePrintOdd = new SemaphorePrintOdd(semaphoreOdd, semaphoreEven);
        Thread t2 = new Thread(semaphorePrintOdd);
        t2.start();

    }

    /**
     * 使用信号量实现
     */
    static class SemaphorePrintOdd implements Runnable {

        private Semaphore semaphoreOdd;
        private Semaphore semaphoreEven;


        public SemaphorePrintOdd(Semaphore semaphoreOdd, Semaphore semaphoreEven) {
            this.semaphoreOdd = semaphoreOdd;
            this.semaphoreEven = semaphoreEven;
        }

        @Override
        public void run() {
            try {
            
                semaphoreOdd.acquire();//获取信号量 semaphoreOdd在初始化的时候被获取了信号量所以这里被阻塞了,所以会先执行下面的奇数线程
                while (true) {
                    i++;
                    if (i % 2 == 0) {
                        System.out.println("偶数线程:" + i);
                        semaphoreEven.release();//释放偶数信号量 让奇数线程那边的阻塞解除
                        //再次申请获取偶数信号量,因为之前已经获取过,如果没有奇数线程去释放,那么就会一直阻塞在这,等待奇数线程释放
                        semaphoreOdd.acquire();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class SemaphorePrintEven implements Runnable {


        private Semaphore semaphoreOdd;
        private Semaphore semaphoreEven;


        public SemaphorePrintEven(Semaphore semaphoreOdd, Semaphore semaphoreEven) {
            this.semaphoreOdd = semaphoreOdd;
            this.semaphoreEven = semaphoreEven;
        }

        @Override
        public void run() {

            try {
          
           
                semaphoreEven.acquire(); 
                while (true) {
                    i++;
                    if (i % 2 == 1) {
                        System.out.println("奇数线程:" + i);
                        semaphoreOdd.release(); //释放奇数信号量 让偶数线程那边的阻塞解除
                        
                //这里阻塞,等待偶数线程释放信号量
                //再次申请获取奇数信号量,需要等偶数线程执行完然后释放该信号量,不然阻塞
                semaphoreEven.acquire();
                    }
                }

            } catch (Exception ex) {}


        }
    }
}
  • 需要注意的是,如果某个线程来不及释放就异常中断了,会导致另一个线程一直在等,造成死锁。 虽然这个异常不在这个问题的考虑范围内 但是可以使用finally 来包裹释放锁资源

同步锁打印

  • 让两个线程使用同一把锁。交替执行 。
    • 判断是不是奇数 如果是奇数进入奇数线程执行打印并加一。然后线程释放锁资源。然后让该线程等待
    • 判断是不是偶数,如果是偶数进入偶数线程执行打印并加一。然后线程释放锁资源。然后让该线程等待
import java.util.concurrent.atomic.AtomicInteger;


/**
 * @ClassName AlternatePrinting
 * @Author yunlogn
 * @Date 2019/5/21
 * @Description 交替打印奇偶数
 */
public class AlternatePrinting {

    public static AtomicInteger atomicInteger = new AtomicInteger(1);

    public static void main(String[] args) throws InterruptedException {

        Thread a=new Thread(new AThread());
        Thread b=new Thread(new BThread());
        a.start();
        b.start();

    }


    public static class AThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                synchronized (atomicInteger) {
                    if (atomicInteger.intValue() % 2 != 0) {
                        System.out.println("奇数线程:" + atomicInteger.intValue());
                        atomicInteger.getAndIncrement();
                        // 奇数线程释放锁资源
                        atomicInteger.notify();
                        try {
                            atomicInteger.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        try {
                            // 奇数线程等待
                            atomicInteger.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    public static class BThread implements Runnable {

        @Override
        public void run() {
            while (true){
                synchronized (atomicInteger){
                    if(atomicInteger.intValue() %2== 0 ){
                        System.out.println("偶数线程:"+ atomicInteger.intValue());
                        atomicInteger.getAndIncrement();
                        // 偶数线程释放锁资源
                        atomicInteger.notify();
                        try {
                            atomicInteger.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        try {
                            // 偶数线程等待
                            atomicInteger.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

}

一种更简单的写法

public class TheadTest {
 
 
    public static void main(String[] args) {
        PrintDigitThread print1 = new PrintDigitThread((i) -> i % 2 == 1, "thread1");
        PrintDigitThread print2 = new PrintDigitThread((i) -> i % 2 == 0, "thread2");
        print1.start();
        print2.start();
    }
}
 
class ShareData {
    public static final AtomicInteger atomicInt = new AtomicInteger(0);
}
 
class PrintDigitThread extends Thread {
    private Predicate<Integer> predicate;
 
    public PrintDigitThread(Predicate<Integer> predicate, String name) {
        this.predicate = predicate;
        this.setName(name);
    }
 
    @Override
    public void run() {
        int v = ShareData.atomicInt.get();
        while (v < 100) {
            synchronized (ShareData.atomicInt) {
                v = ShareData.atomicInt.get();
                if (predicate.test(v)) {
                    System.out.println(Thread.currentThread().getName() + ":" + v);
                    ShareData.atomicInt.incrementAndGet();
                    try {
                        ShareData.atomicInt.notify();
                    } catch (Exception ex) {
 
                    }
                } else {
                    try {
                        ShareData.atomicInt.wait();
                    } catch (Exception ex) {
 
                    }
                }
            }
        }
    }
}

欢迎关注  http://yunlongn.github.io

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 什么是Servlet(原理,从访问到方法)

    Servlet是SUN公司提供的一门用于开发动态WEB资源的技术。SUN公司在其API中提供了一个Servlet接口,用户若想开发一个动态WEB资源(即开发一个...

    yunlgonn
  • Java 高级 --- 多线程快速入门

    Thread.yield()方法的作用:暂停当前正在执行的线程,并执行其他线程。(可能没有效果) yield()让当前正在运行的线程回到可运行状态,以允许具有...

    yunlgonn
  • Java 设计模式

    yunlgonn
  • 【快学springboot】10.使用@Async注解创建多线程,自定义线程池

    使用@Async注解创建多线程非常的方便,还可以通过配置,实现线程池。比直接使用线程池简单太多。而且在使用上跟普通方法没什么区别,加上个@Async注解即可实现...

    Happyjava
  • 计算机程序的思维逻辑 (11) - 初识函数

    查看上节内容,请点击上方链接关注公众号,查看所有文章。 函数 前面几节我们介绍了数据的基本类型、基本操作和流程控制,使用这些已经可以写不少程序了。 但是如果需...

    swiftma
  • 【今日问题】变量未初始化引起的崩溃

    昨天写的今日问题,有小伙伴给我反馈,觉得挺有用,小编今天继续给小伙伴们总结遇到的常见问题 一、初学者经常由于没有养成良好的编程习惯,未初始化变量会引起那些问题 ...

    程序员互动联盟
  • linux系统编程之基础必备(六):可重入函数、线程安全、volatile

    一、 POSIX 中对可重入和线程安全这两个概念的定义: Reentrant Function:A function whose effect, ...

    s1mba
  • Java并发编程实战系列16之Java内存模型(JMM)

    前面几章介绍的安全发布、同步策略的规范还有一致性,这些安全性都来自于JMM。 16.1 什么是内存模型,为什么需要它? 假设 a=3 内存模型要解决的问题是:...

    JavaEdge
  • 信号量

    Hystrix内部提供了两种模式执行逻辑:信号量和线程池。默认情况下,Hystrix使用线程池模式。那什么是信号量呢?

    只喝牛奶的杀手
  • Scala 学习笔记之高阶函数

    Scala混合了面向对象和函数式的特性.在函数式编程语言中,函数可以像任何其他数据类型一样被传递和操作.如果想要给算法传入明细动作时,只需要将明细动作包在函数当...

    smartsi

扫码关注云+社区

领取腾讯云代金券