Tao Gong breeze through the ages, I who, dare to say a few ordinary

Personal Blog:www.breez.work CSDN:BreezAm

Notation 1: Use Semaphore

public class Foo {

    private Semaphore semaphoreB = new Semaphore(0);
    private Semaphore semaphoreC = new Semaphore(0);

    public Foo(a) {}

    public void first(a) throws InterruptedException {
        System.out.println("A");
        semaphoreB.release();
    }

    public void second(a) throws InterruptedException {
        semaphoreB.acquire();
        System.out.println("B");
        semaphoreC.release();
    }

    public void third(a) throws InterruptedException {
        semaphoreC.acquire();
        System.out.println("C"); }}Copy the code

Synchronized lock

public class Foo {

    private Object lock = new Object();
    private boolean a;
    private boolean b;

    public Foo(a) {}

    public void first(a) throws InterruptedException {
        synchronized (lock) {
            System.out.println("A");
            a = true; lock.notifyAll(); }}public void second(a) throws InterruptedException {
        synchronized (lock) {
            while(! a) { lock.wait(); } System.out.println("B");
            b = true; lock.notifyAll(); }}public void third(a) throws InterruptedException {
        synchronized (lock) {
            while(! b) { lock.wait(); } System.out.println("C"); }}}Copy the code

Use atomic AtomicInteger

public class Foo {

    private AtomicInteger a2 = new AtomicInteger(0);
    private AtomicInteger a3 = new AtomicInteger(0);

    public Foo(a) {}

    public void first(a) throws InterruptedException {
        System.out.println("A");
        a2.incrementAndGet();
    }

    public void second(a) throws InterruptedException {
        while(a2.get() ! =1) {}
        System.out.println("B");
        a3.incrementAndGet();
    }

    public void third(a) throws InterruptedException {
        while(a3.get() ! =1) {}
        System.out.println("C"); }}Copy the code

Use BlockingQueue

public class Foo {

    BlockingQueue<String> queue2 = new ArrayBlockingQueue<>(1);
    BlockingQueue<String> queue3 = new ArrayBlockingQueue<>(1);
    
    public Foo(a) {}

    public void first(a) throws InterruptedException {
        System.out.println("A");
        queue2.offer("b");
    }

    public void second(a) throws InterruptedException {
        while (queue2.size() == 0) {
        }
        System.out.println("B");
        queue3.offer("c");
    }

    public void third(a) throws InterruptedException {
        while (queue3.size() == 0) {
        }
        System.out.println("C"); }}Copy the code

Notation 5: Use Condition

public class Foo {

    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition a = lock.newCondition();
    private Condition b = lock.newCondition();
    private Condition c = lock.newCondition();

    public Foo(a) {}

    public void first(a) throws InterruptedException {
        lock.lock();
        try {
            while(number ! =1) {
                a.await();
            }
            System.out.println("A");
            number = 2;
            b.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally{ lock.unlock(); }}public void second(a) throws InterruptedException {
        lock.lock();
        try {
            while(number ! =2) {
                b.await();
            }
            System.out.println("B");
            number = 3;
            c.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally{ lock.unlock(); }}public void third(a) throws InterruptedException {
        lock.lock();
        try {
            while(number ! =3) {
                c.await();
            }
            System.out.println("C");
        } catch (Exception e) {
            e.printStackTrace();
        } finally{ lock.unlock(); }}}Copy the code

6. Use the counter CountDownLatch

public class Foo {

    private CountDownLatch c2 = new CountDownLatch(1);
    private CountDownLatch c3 = new CountDownLatch(1);

    public Foo(a) {}

    public void first(a) throws InterruptedException {
        System.out.println("A");
        c2.countDown();
    }

    public void second(a) throws InterruptedException {
        c2.await();
        System.out.println("B");
        c3.countDown();
    }

    public void third(a) throws InterruptedException {
        c3.await();
        System.out.println("C"); }}Copy the code

The test code

public static void main(String[] args) throws InterruptedException {
        Foo foo = new Foo();
        new Thread(() -> {
            try {
                foo.first();
            } catch(InterruptedException e) { e.printStackTrace(); }},"A").start();
        new Thread(() -> {
            try {
                foo.second();
            } catch(InterruptedException e) { e.printStackTrace(); }},"B").start();

        new Thread(() -> {
            try {
                foo.third();
            } catch(InterruptedException e) { e.printStackTrace(); }},"C").start();
    }
Copy the code