多线程同步之——两个线程串行顺序打印奇数和偶数的两种实现

题目：一道经典的线程并发的问题，线程a打印1、3、5……，线程b打印2、4、6……，两个线程交替执行输出1、2、3、4、5、6……
要点：

package com.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * desc:Thread Counter
 */
public class Counter {

    private static Lock lock = new ReentrantLock();
    private static Condition conditionOne = lock.newCondition();
    private static Condition conditionTow = lock.newCondition();
    private static volatile boolean isFlag = false;
    private static Object object = new Object();
    public static void main(String[] args) {
        System.out.println("Lock Condition:");
        methodOne();
        System.out.println("synchronized wait notify");
        methodTow();
    }

    /**
     * lock and condition
     */
    private static void methodOne() {
        Thread threadA = new Thread(new Runnable() {
            public void run() {
                int i = 1;
                while (i <= 99) {
                    if (!isFlag) {
                        lock.lock();
                        try {
                            System.out.println("threadA:" + i);
                            isFlag = true;
                            conditionOne.await();
                            conditionTow.signal();
                            i += 2;
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.unlock();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            public void run() {
                int i = 2;
                while (i <= 100) {
                    if (isFlag) {
                        lock.lock();
                        try {
                            System.out.println("threadB:" + i);
                            isFlag = false;
                            conditionOne.signal();
                            conditionTow.await();
                            i += 2;
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.unlock();
                    }

                }
            }
        });

        threadA.setPriority(Thread.MAX_PRIORITY);
        try {
            threadB.start();
            Thread.sleep(1000);
            threadA.start();
            threadA.join();
            threadB.join();
            System.out.println("ok");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    /**
     * synchronized wait notify
     */
    public static void methodTow() {
         Thread threadA = new Thread(new Runnable() {
            public void run() {
                int i = 1;
                while (i <= 99) {
                    if (!isFlag) {
                        synchronized (object) {
                            System.out.println("threadA:" + i);
                            i += 2;
                            isFlag = true;
                            try {
                                if (i < 99) {
                                    object.wait();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            object.notify();
                        }
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            public void run() {
                int i = 2;
                while (i <= 100) {
                    if (isFlag) {
                        synchronized (object) {
                            System.out.println("threadB:" + i);
                            isFlag = false;
                            i += 2;
                            object.notify();
                            try {
                                if (i < 100) {
                                    object.wait();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        });
        try {
            threadA.setPriority(Thread.MAX_PRIORITY);
            Thread.sleep(1000);
            threadB.start();
            threadA.start();
            threadA.join();
            threadB.join();
            System.out.println("ok");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}