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

//第二题是  创建两个线程交替输出 1-10所有的数字
public class ThreadTest {
        
        private static int count = 0;
        
        private static Lock lock = new ReentrantLock();//新建一个锁对象
        private static Condition con = lock.newCondition();//获取一个 与锁绑定的condition对象
        private static boolean flag = false;//用于线程间通信
        
        //每调用一次函数输出count一次，输出后count加1
        public static void out() {// 多个线程或调用这个函数，所以需要就其进行同步
                if (count <= 10) {
                        System.out
                                        .println(count++ + "..." + Thread.currentThread().getName());
                }
        }

        public static void main(String[] args) throws Exception{
                new Thread(new Runnable() {
                        public void run() {
                                for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
//                                        synchronized(lock){
                                        lock.lock();//从这里锁定，只允许一个线程进入
                                                while (flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
                                                        try {
//                                                                lock.wait();
                                                                con.await();
                                                        } catch (InterruptedException e) {
                                                                e.printStackTrace();
                                                        }
                                                out();
                                                flag = true;
//                                                lock.notifyAll();
                                                con.signalAll();
                                                lock.unlock();//解锁
                                        }
//                                }
                        }
                }).start();
                new Thread(new Runnable() {
                        public void run() {
                                for (int i = 0; i < 5; i++) {//因为要输出10次，所以每个线程只需要调用5次 out()函数
//                                        synchronized(lock){
                                        lock.lock();//从这里锁定，只允许一个线程进入
                                                while (!flag)//内部类访问局部变量时，变量必须是常量，所以把flag定义在类里
                                                        try {
//                                                                lock.wait();
                                                                con.await();
                                                        } catch (InterruptedException e) {
                                                                e.printStackTrace();
                                                        }
                                                out();
                                                flag = false;
//                                                lock.notifyAll();
                                                con.signalAll();
                                                lock.unlock();//解锁
                                        }
//                                }
                        }
                }).start();
        }
}

0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.