java生成随机筛子

题目要求：

两个线程，一个线程随机生成筛子数，一个线程在控制台中打印线程数，如果连续生成3个6，则两个线程退出。

实现代码（一）

import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

public class DemoA {

    LinkedList<Integer> list = new LinkedList<>();
    AtomicInteger count = new AtomicInteger();

    class Thread1 implements Runnable {
        @Override
        public void run() {
            while (count.get() < 3) {
                synchronized (list) {
                    if(list.size()>0){
                        try {
                            list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    Random random = new Random();
                    int i = random.nextInt(6) + 1;
                    list.push(i);
                    if(i==6){
                        int c=count.get()+1;
                        count.set(c);
                    }else {
                        count.set(0);
                    }

                }
            }
        }
    }

    class Thread2 implements Runnable {
        @Override
        public void run() {
            while (count.get() < 3) {
                synchronized (list) {
                    if (list.size() > 0) {
                        System.out.println(list.pop());
                    }else {
                        list.notify();
                    }
                }
            }
        }
    }

    public void start() {
        Thread thr1 = new Thread(new Thread1());
        thr1.start();

        Thread thr2 = new Thread(new Thread2());
        thr2.start();
    }

    public static void main(String[] args) {
        DemoA demoA = new DemoA();
        demoA.start();
    }
}

实现代码（二）

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 摇筛子，一个线程读，一个线程在控制台打印，如果连续出现3个6，则退出。
 */
public class BlockQueueTest {
    public static void main(String[] args) {
        BlockQueueTest blockQueueTest=new BlockQueueTest();
        blockQueueTest.start();
    }

    private void start(){
        Bus bus=new Bus();

        new Thread(bus::send).start();
        new Thread(bus::take).start();
    }

    class Bus{
        BlockingQueue<Integer> queue=new ArrayBlockingQueue<>(1);
        AtomicInteger integer=new AtomicInteger();

        private void send(){
            while (integer.get()<3){
                Random random=new Random();
                int i=random.nextInt(6)+1;
                try {
                    queue.put(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(i==6){
                    int c=integer.get()+1;
                    integer.set(c);
                }else {
                    integer.set(0);
                }
            }
        }

        private void take(){
            while (integer.get()<3||queue.size()!=0){
                try {
                    System.out.println(queue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}