1.按序打印

解法一：使用volatile

public class FooWithVolatile {
    private volatile int count;

    public FooWithVolatile() {

    }

    public void first(Runnable printFirst) throws InterruptedException {
        // printFirst.run() outputs "first". Do not change or remove this line.
        printFirst.run();
        count++;

    }

    public void second(Runnable printSecond) throws InterruptedException {
        // printSecond.run() outputs "second". Do not change or remove this line.
        while(count != 1) { }
        printSecond.run();
        count++;
    }

    public void third(Runnable printThird) throws InterruptedException {
    	while(count != 2) { }
        // printThird.run() outputs "third". Do not change or remove this line.
        printThird.run();
    }
}

类似的，我们也可以使用AtomicInteger，不过其实AtomicInteger底层也是使用了volatile字段，只不过在计算时会使用CAS解决原子性问题，但是这里的while循环对自增操作进行了阻塞，所以不会出现三个线程同时对count自增的情况，所以没必要使用AtomicInteger，更何况CAS操作里面的while循环也是很耗费资源的

解法二：使用CountDownLatch

public class FooWithCountDownLatch {
    private CountDownLatch second = new CountDownLatch(1);
    private CountDownLatch third = new CountDownLatch(1);

    public FooWithCountDownLatch() {
    }

    public void first(Runnable printFirst) throws InterruptedException {
        // printFirst.run() outputs "first". Do not change or remove this line.
        printFirst.run();
        second.countDown();
    }

    public void second(Runnable printSecond) throws InterruptedException {
    	second.await();
        // printSecond.run() outputs "second". Do not change or remove this line.
        printSecond.run();
        third.countDown();
    }

    public void third(Runnable printThird) throws InterruptedException {
    	third.await();
        // printThird.run() outputs "third". Do not change or remove this line.
        printThird.run();
    }
}

类似的，这里我们使用两个“门栓”栓住（阻塞）second方法和third方法执行run方法打印结果，当first方法执行完毕后，释放second的门栓让second方法打印结果，second方法执行完毕后，释放third的门栓让third方法打印结果

2.交替打印FooBar

class FooBarWithCountDownLatch {
    private int n;
    private CountDownLatch fooLatch = new CountDownLatch(0);
    private CountDownLatch barLatch = new CountDownLatch(1);

    public FooBarWithCountDownLatch(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {

        for (int i = 0; i < n; i++) {
            fooLatch.await();
            // printFoo.run() outputs "foo". Do not change or remove this line.
            printFoo.run();
            fooLatch = new CountDownLatch(1);
            barLatch.countDown();
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {

        for (int i = 0; i < n; i++) {
            barLatch.await();
            // printBar.run() outputs "bar". Do not change or remove this line.
            printBar.run();
            barLatch = new CountDownLatch(1);
            fooLatch.countDown();
        }
    }
}

这里要注意，CountDownLatch和CyclicBarrier不一样，CountDownLatch是一次性的，countDown到0之后不会自己恢复成1，所以要每次new一个CountDownLatch对象。

3.打印零与奇偶数

public class ZeroEvenOdd {
    private int n;
    private CountDownLatch zero = new CountDownLatch(0);
    private CountDownLatch even = new CountDownLatch(1);
    private CountDownLatch odd = new CountDownLatch(1);

    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            zero.await();
            printNumber.accept(0);
            zero = new CountDownLatch(1);
            if(i % 2 == 0) {
                odd.countDown();
            } else {
                even.countDown();
            }
        }
        
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i < n; i+=2) {
            even.await();
            printNumber.accept(i);
            even = new CountDownLatch(1);
            zero.countDown();
        }

    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i < n; i+=2) {
            odd.await();
            printNumber.accept(i);
            odd = new CountDownLatch(1);
            zero.countDown();
        }
    }
}

这道题没什么好说的，做法也同样很多样，只要仔细点，都可以做对，但是我感觉都没直接用CoutDownLatch好。

4.H2O

public class H2O {
    private Semaphore hSemaphore = new Semaphore(2);
    private Semaphore oSemaphore = new Semaphore(0);

    public H2O() {

    }

    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
        hSemaphore.acquire();
        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
        releaseHydrogen.run();
        oSemaphore.release();
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        oSemaphore.acquire(2);
        // releaseOxygen.run() outputs "H". Do not change or remove this line.
        releaseOxygen.run();
        hSemaphore.release(2);
    }
}

实在想不到Semaphore以外的做法，虽然看题解确实有，但是反而不怎么好

LeetCode上专门的多线程题目版块，本文通过解决几道leetCode上的多线程协作交替打印的编程题，来加深对并发编程的理解，并训练一下并发编程思想。

一、交替打印

交替打印FooBar

示例
输入: n = 2
输出: “foobarfoobar”
解释: “foobar” 将被输出两次。

方法1：synchronized锁

背景知识
1、wait()使当前线程阻塞，前提是必须先获得锁，一般配synchronized 关键字使用，即只能在synchronized同步代码块里使用wait()、notify/notifyAll()方法。

2、 由于wait()、notify/notifyAll()在synchronized 代码块执行，说明当前线程一定是获取了锁的。当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。只有当notify/notifyAll()被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized代码块的代码或是中途遇到wait() ，才释放锁。

3、notify/notifyAll()的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll()后立即退出临界区，以唤醒其他线程让其获得锁。

4、notify和wait的顺序不能错，如果A线程先执行notify方法，B线程再执行wait方法，那么B线程是无法被唤醒的。

5、notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。notifyAll会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。如果当前情况下有多个线程需要被唤醒，推荐使用notifyAll方法。比如在生产者——消费者场景下使用，每次都需要唤醒所有的消费者或是生产者，以判断程序是否可以继续往下执行。

public class FooBarSync {

    private  int n;
    private  volatile boolean fooExec = true;

    public FooBarSync(int n) {
        this.n = n;
    }
    
    public void foo() throws InterruptedException {
        int i = 0;
        synchronized (this) {
            while (i < n) {
                if (fooExec) {
                    System.out.print("foo");
                    i++;
                    fooExec = false;
                    this.notifyAll();
                } else {
                    //foo线程等待
                    this.wait();
                }
            }
        }
    }

    public void bar() throws InterruptedException {
        int i = 0;
        synchronized (this) {
            while (i < n) {
                if (!fooExec) {
                    System.out.print("bar");
                    i++;
                    fooExec = true;
                    this.notifyAll();
                } else {
                    //bar线程等待
                    this.wait();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FooBarSync fooBar = new FooBarSync(5);
        new Thread(()-> {
            try {
                fooBar.foo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()-> {
            try {
                fooBar.bar();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

方法2：ReentrantLock

背景知识
ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。CAS是一个原子操作，被广泛的应用在Java的底层实现中。在Java中，CAS主要是由sun.misc.Unsafe这个类通过JNI调用CPU底层指令实现。

ReentrantLock和synchronized都是独占锁，只允许线程互斥的访问临界区。但是实现上两者不同：synchronized加锁解锁的过程是隐式的,用户不用手动操作，优点是操作简单，但显得不够灵活。一般并发场景使用synchronized的就够了；ReentrantLock需要手动加锁和解锁，且解锁的操作尽量要放在finally代码块中，保证线程正确释放锁。

public class FooBarLock {
    private  int n;
    private  ReentrantLock lock = new ReentrantLock();
    private  volatile boolean fooExec = true;

    public FooBarLock(int n) {
        this.n = n;
    }
    public void foo() throws InterruptedException {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (fooExec) {
                    System.out.print("foo");
                    fooExec = false;
                    i++;
                }
            } finally {
                lock.unlock();
            }
        }
    }
    public void bar() throws InterruptedException {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (!fooExec) {
                    System.out.print("bar");
                    fooExec = true;
                    i++;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FooBarLock fooBar = new FooBarLock(5);
        new Thread(()-> {
            try {
                fooBar.foo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()-> {
            try {
                fooBar.bar();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

二、打印零与奇偶数

打印零与奇偶数

示例
输入：n = 2
输出：“0102”
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 “0102”。

输入：n = 5
输出：“0102030405”

方法1：ReentrantLock + Condition

Condition强大的地方在于它能够精确的控制多线程的休眠与唤醒（注意是唤醒，唤醒只意味着进入了同步队列，不意味着一定能获得资源），相比使用Object的wait()/notify()，使用Condition的await()/signal()这种方式能够更加安全和高效地实现线程间协作。

public class ZeroEvenOdd {
    /**
     * 最后一个打印的数字
     */
    private int n;
    /**
     * 控制打印的标志变量
     * flag = 1表示要打印奇数了，flag = 2表示要打印偶数了，flag = 0表示打印0
     */
    private int flag = 0;
    
    private Lock lock = new ReentrantLock();
    private Condition zeroCondition = lock.newCondition();
    private Condition evenCondition = lock.newCondition();
    private Condition oddCondition = lock.newCondition();

    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    // 仅打印出 0
    public void zero(IntConsumer printNumber) throws InterruptedException {
        lock.lock();
        try {
            for (int i = 1; i <= n; i++) {
                if (flag != 0) {
                    // zero线程等待
                    zeroCondition.await();
                }
                printNumber.accept(0);
                if (i % 2 == 1) {
                    flag = 1;
                    // 指定唤醒odd线程
                    oddCondition.signal();
                } else {
                    flag = 2;
                    // 指定唤醒even线程
                    evenCondition.signal();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    // 仅打印出 偶数
    public void even(IntConsumer printNumber) throws InterruptedException {
        lock.lock();
        try {
            for (int i = 2; i <= n; i += 2) {
                if (flag != 2) {
                    // even线程等待
                    evenCondition.await();
                }
                printNumber.accept(i);
                flag = 0;
                // 唤醒zero线程
                zeroCondition.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    // 仅打印出 奇数
    public void odd(IntConsumer printNumber) throws InterruptedException {
        lock.lock();
        try {
            for (int i = 1; i <= n; i += 2) {
                if (flag != 1) {
                    // odd线程等待
                    oddCondition.await();
                }
                printNumber.accept(i);
                flag = 0;
                // 唤醒zero线程
                zeroCondition.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
         ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(5);
         new Thread(()-> {
             try {
                 zeroEvenOdd.odd(e -> System.out.print(e));
             } catch (InterruptedException e) {
             }
         }).start();
        new Thread(()-> {
            try {
                zeroEvenOdd.zero(e -> System.out.print(e));
            } catch (InterruptedException e) {
            }
        }).start();
        new Thread(()-> {
            try {
                zeroEvenOdd.even(e -> System.out.print(e));
            } catch (InterruptedException e) {
            }
        }).start();
    }
}

方法2：CountDownLatch

背景知识
CountDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在锁上等待的线程就可以恢复工作了

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException;   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException;  
//将count值减1
public void countDown();  

public class ZeroEvenOdd {
    /**
     * 最后一个打印的数字
     */
    private int n;
    private CountDownLatch zeroLatch = new CountDownLatch(1);
    private CountDownLatch evenLatch = new CountDownLatch(1);
    private CountDownLatch oddLatch = new CountDownLatch(1);

    public ZeroEvenOdd(int n) {
        this.n = n;
    }
    // 仅打印出 0
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            zeroLatch = new CountDownLatch(1);
            printNumber.accept(0);
            // 如果已经打印了奇数个0，那么接下来要打印奇数
            if ((i&1) == 1) {
                oddLatch.countDown();
            } else {
                evenLatch.countDown();
            }
            // 当前线程挂起，直到值减为0
            zeroLatch.await();
        }
    }
    // 仅打印出 偶数
    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i <= n; i += 2) {
            evenLatch.await();
            printNumber.accept(i);
            // 接下来要打印0
            evenLatch = new CountDownLatch(1);
            zeroLatch.countDown();
        }
    }
    // 仅打印出 奇数
    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i += 2) {
            oddLatch.await();
            printNumber.accept(i);
            // 接下来要打印0
            oddLatch = new CountDownLatch(1);
            zeroLatch.countDown();
        }
    }

    public static void main(String[] args) {
        ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(5);
        new Thread(()-> {
            try {
                zeroEvenOdd.odd(e -> System.out.print(e));
            } catch (InterruptedException e) {
            }
        }).start();
        new Thread(()-> {
            try {
                zeroEvenOdd.zero(e -> System.out.print(e));
            } catch (InterruptedException e) {
            }
        }).start();
        new Thread(()-> {
            try {
                zeroEvenOdd.even(e -> System.out.print(e));
            } catch (InterruptedException e) {
            }
        }).start();
    }
}

三、手写阻塞队列

实现一个有界阻塞队列，拥有put方法与take方法，当队列满时put方法阻塞，当队列空时take方法阻塞。

public class MyBlockingQueue {

    private Deque<Integer> queue;
    private int capacity;

    private Lock lock = new ReentrantLock();
    private Condition isFull = lock.newCondition();
    private Condition isEmpty = lock.newCondition();

    public MyBlockingQueue(int capacity) {
        this.queue = new LinkedList<>();
        this.capacity = capacity;
    }
    
    public void put(String item) throws InterruptedException {
        lock.lock();
        try {
            // 队列已满
            while (queue.size() >= capacity) {
                // put线程等待
                isFull.await();
            }
            queue.addLast(item);
            // 唤醒take线程
            isEmpty.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public String take() throws InterruptedException {
        lock.lock();
        String res = null;
        try {
            // 队列已满
            while (container.size() == 0) {
                // take线程等待
                isEmpty.await();
            }
            res = queue.pollFirst();
            // 唤醒put线程
            isFull.signalAll();
            return res;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        MyBlockingQueue blockingQueue = new MyBlockingQueue(64);
        new Thread(()-> {
            for (int i = 0; i < 100; i++) {
                try {
                    blockingQueue.put(String.valueOf(i));
                    System.out.println("放入" + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();

        new Thread(()-> {
            for (;;) {
                try {
                    System.out.println("取出" + blockingQueue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();
    }
}

四、按顺序输出字符串

问题描述：有4个线程和1个公共的字符串数组。线程1的功能就是向数组输出A，线程2的功能就是向数组输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由输入的参数指定。请编写一个类，类中封装公共字符串数组及输出逻辑，4个不同的线程将会共用一个该类的实例。

方法1：ReentrantLock + Condition

Condition强大的地方在于它能够精确的控制多线程的休眠与唤醒（注意是唤醒，唤醒只意味着进入了同步队列，不意味着一定能获得资源），相比使用Object的wait()/notify()，使用Condition的await()/signal()这种方式能够更加安全和高效地实现线程间协作。

public class AbcdLock {
    private List<String> strList;
    private int n;

    private Lock lock = new ReentrantLock();
    private Condition aCondition = lock.newCondition();
    private Condition bCondition = lock.newCondition();
    private Condition cCondition = lock.newCondition();
    private Condition dCondition = lock.newCondition();

    public AbcdLock(List<String> strList, int n) {
        this.strList = strList;
        this.n = n;
    }

    public void addA() {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (strList.size() % 4 != 0) {
                    // 添加A的线程等待
                    aCondition.await();
                }
                strList.add("A");
                i++;
                // 指定唤醒添加B的线程
                bCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    public void addB() {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (strList.size() % 4 != 1) {
                    // 添加B的线程等待
                    bCondition.await();
                }
                strList.add("B");
                i++;
                // 指定唤醒添加C的线程
                cCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    public void addC() {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (strList.size() % 4 != 2) {
                    // 添加C的线程等待
                    cCondition.await();
                }
                strList.add("C");
                i++;
                // 指定唤醒添加D的线程
                dCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    public void addD() {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
                if (strList.size() % 4 != 3) {
                    // 添加A的线程等待
                    dCondition.await();
                }
                strList.add("D");
                i++;
                // 指定唤醒添加A的线程
                aCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        List<String> strList = new ArrayList<>(128);
        AbcdLock abcdLock = new AbcdLock(strList, 4);
        new Thread(() -> {
            abcdLock.addA();
        }).start();
        new Thread(() -> {
            abcdLock.addB();
        }).start();
        new Thread(() -> {
            abcdLock.addC();
        }).start();
        new Thread(() -> {
            abcdLock.addD();
        }).start();
    }

方法2：synchronized关键字

只用一个Object锁，4个线程同时竞争一个锁，然后同时唤醒再竞争，再附加一个条件变量就行了。

将要输入的字符串以及字符串的丢失顺序，作为变量传入。只有当数组当前索引与本线程要输入字符串的位置匹配时，才做输入动作，否则线程等待。

public class AbcdSync extends Thread {

    private List<String> strList;
    private String       element;
    private int          cycle;
    // 用一个变量来规定要输入字符串的顺序，例如0、1、2、3
    private int          index;

    public AbcdSync(List<String> strList, String element, int cycle, int index) {
        this.strList = strList;
        this.element = element;
        this.cycle = cycle;
        this.index = index;
    }

    @Override
    public void run()  {
        try {
            for (int i = 0;i < cycle;) {
                synchronized (strList) {
                    // 这里的判断是关键
                    if (strList.size() % 4 == index) {
                        strList.add(element);
                        i++;
                        // 唤醒其他所有线程
                        strList.notifyAll();
                    } else {
                        // 当前线程阻塞
                        strList.wait();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        List<String> strList = new ArrayList<>(256);
        new AbcdSync(strList, "A", 4, 0).start();
        new AbcdSync(strList, "B", 4, 1).start();
        new AbcdSync(strList, "C", 4, 2).start();
        new AbcdSync(strList, "D", 4, 3).start();
    }
}