阿里算法题：打印100 ，一个线程打印5的倍数，一个线程打印3 的倍数,另外一个线程打印其他数

java面试题网站：www.javaoffers.compackage com.mh.others.arithmetic;

import org.junit.Test;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 阿里算法，打印100 ，一个线程打印5的倍数，一个线程打印3 的倍数,另外一个线程打印其他数
 *
 */
public class ArithPrint {
    private static Object blockOne = new Object();
    private static Object blockTwo = new Object();
    private static Object blockThree = new Object();

    private static volatile Integer bs = null;//倍数
    private static volatile AtomicBoolean stop = new AtomicBoolean(false) ; //是否停止打印

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

        //线程One
        Thread one =  new Thread(new Runnable() { //打印其他
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (blockOne){
                    for(int i = 1;i<=100;i++){
                        if(i%3==0){ //如果是三的倍数，让blockTwo打印
                            //设置倍数
                            bs = i/3;
                            //开始让BlockTwo 打印
                            synchronized (blockTwo){
                                blockTwo.notify();
                            }

                            try {
                                blockOne.wait();
                                if(stop.get()){
                                    break;
                                }
                                continue;
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }

                        }else if(i%5 == 0){ //如果是5的倍数，让blockThree打印
                            //设置倍数
                            bs = i/5;
                            //开始让BlockThree打印
                            synchronized (blockThree){
                                blockThree.notify();
                            }
                            try {
                                blockOne.wait();
                                if(stop.get()){
                                    break;
                                }
                                continue;
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }else{
                            System.out.println(i);
                            if(i==100){
                                stop.set(true);
                                synchronized (blockTwo) {
                                    blockTwo.notify();
                                }
                                synchronized (blockThree){
                                    blockThree.notify();
                                }
                                break;
                            }
                        }
                    }
                    stop.set(true);
                    if(stop.get()){
                        synchronized (blockTwo) {
                            blockTwo.notify();
                        }
                        synchronized (blockThree){
                            blockThree.notify();
                        }
                    }
                }



            }
        });one.start();

        //线程Two
        Thread two = new Thread(new Runnable() { //打印 3的倍数
            @Override
            public void run() {
                synchronized (blockTwo){
                    while(true){
                        try {
                            if(stop.get()){
                                break;
                            }
                            System.out.println("blockTwo start wait");
                            blockTwo.wait();
                            if(stop.get()){
                                break;
                            }
                            System.out.println(3*bs);

                            if(3*bs == 100){
                                stop.set(true);
                                synchronized (blockThree){
                                    blockThree.notify();
                                }
                                synchronized (blockOne) {
                                    blockOne.notify();
                                }
                                break;
                            }else{
                                synchronized (blockOne) {
                                    blockOne.notify();
                                }

                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }



                }

            }
        });two.start();

        //线程Three
        Thread three = new Thread(new Runnable() { //打印 5的倍数
            @Override
            public void run() {
                synchronized (blockThree){
                    while(true){
                        try {
                            if(stop.get()){
                                break;
                            }
                            System.out.println("blockThree start wait");
                            blockThree.wait();
                            if(stop.get()){
                                break;
                            }
                            System.out.println(5*bs);

                            if(5*bs == 100){
                                stop.set(true);
                                synchronized (blockTwo){
                                    blockTwo.notify();
                                }

                                synchronized (blockOne) {
                                    blockOne.notify();
                                }

                                break;
                            }else{
                                synchronized (blockOne) {
                                    blockOne.notify();
                                }

                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });three.start();

        one.join();
    }
}

解决思路： one线程负责打印，并且决定让two或three 根据倍数去打印