Condition和Semaphore以及Blockingqueue实现打印零与奇偶数

1.Condition实现

import org.junit.jupiter.api.Test;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyTest {
    private ReentrantLock lock = new ReentrantLock();
    private AtomicInteger atomic = new AtomicInteger(0);
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int n = 20;
    boolean flag1 = false;
    boolean flag2 = false;

    @Test
    public void test() throws InterruptedException {
        Thread t1 = new Thread(new Runnable1());
        Thread t2 = new Thread(new Runnable2());
        Thread t3 = new Thread(new Runnable3());
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
    }

    private class Runnable1 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n) {
                try {
                    if (atomic.get() % 2 ==0) {
                        while (!flag1) {
                            Thread.yield();
                        }
                    } else {
                        while (!flag2) {
                            Thread.yield();
                        }
                    }
                    lock.lock();
                    System.out.println(0);
                    if (atomic.get() % 2 == 0) {
                        flag1 = false;
                        condition2.signal();
                    } else {
                        flag2 = false;
                        condition3.signal();
                    }
                    //这里释放锁 其他线程才能拿到
                    condition1.await();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    private class Runnable2 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n-1) {
                try {
                    lock.lock();
                    flag1 = true;
                    condition2.await();
                    System.out.println(atomic.incrementAndGet());
                    condition1.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    private class Runnable3 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n) {
                try {
                    lock.lock();
                    flag2 = true;
                    condition3.await();
                    System.out.println(atomic.incrementAndGet());
                    condition1.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

2.Semaphore实现

import org.junit.jupiter.api.Test;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;


public class MyTest {
    private int n = 30;
    AtomicInteger atomic = new AtomicInteger(0);
    Semaphore se1 = new Semaphore(1);
    Semaphore se2 = new Semaphore(0);
    Semaphore se3 = new Semaphore(0);

    @Test
    public void test() throws InterruptedException {
        Thread t1 = new Thread(new Runnable1());
        Thread t2 = new Thread(new Runnable2());
        Thread t3 = new Thread(new Runnable3());
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
    }

    private class Runnable1 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n - 1) {
                try {
                    se1.acquire();
                    System.out.println(0);
                    if (atomic.get()%2 == 0) {
                        se2.release();
                    } else {
                        se3.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Runnable2 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n - 1) {
                try {
                    se2.acquire();
                    System.out.println(atomic.incrementAndGet());
                    se1.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Runnable3 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n) {
                try {
                    se3.acquire();
                    System.out.println(atomic.incrementAndGet());
                    se1.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.BlockingQueue实现

import org.junit.jupiter.api.Test;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;


public class MyTest {
    private int n = 30;
    AtomicInteger atomic = new AtomicInteger(0);
    LinkedBlockingQueue<Integer> q1 = new LinkedBlockingQueue<>(1);
    LinkedBlockingQueue<Integer> q2 = new LinkedBlockingQueue<>(1);
    LinkedBlockingQueue<Integer> q3 = new LinkedBlockingQueue<>(1);

    @Test
    public void test() throws InterruptedException {
        Thread t1 = new Thread(new Runnable1());
        Thread t2 = new Thread(new Runnable2());
        Thread t3 = new Thread(new Runnable3());
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
    }

    private class Runnable1 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n - 1) {
                try {
                    q1.put(1);
                    System.out.println(0);
                    if (atomic.get()%2==0) {
                        q2.put(1);
                    } else {
                        q3.put(1);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Runnable2 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n - 1){
                try {
                    q2.take();
                    System.out.println(atomic.incrementAndGet());
                    q1.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Runnable3 implements Runnable {
        @Override
        public void run() {
            while (atomic.get() < n) {
                try {
                    q3.take();
                    System.out.println(atomic.incrementAndGet());
                    q1.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}