java生成隨機篩子

版權聲明：本文爲博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/erdongritian/article/details/81288541

題目要求：

兩個線程，一個線程隨機生成篩子數，一個線程在控制檯中打印線程數，如果連續生成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();
                }
            }
        }
    }

}