本文直接附上源代码，如下是自己写的一个例子

面试题
需求: 使用Condition来实现
三个线程
线程1
线程2
线程3
三个交替输出
【按照 线程1(main)-->线程2-->线程3】
如此往复50次 请写出程序

  1 public class ThreeConditionCommunication
  2 {
  3     /**
  4      * 用于标记那个线程进行执行 
  5      * 1:主线程
  6      * 2:线程2
  7      * 3:线程3
  8      */
  9     private static int HASOUT = 1;
 10     public static void main(String[] args) throws InterruptedException
 11     {
 12         final Core core = new Core();
 13         //子线程2
 14         new Thread(
 15                 new Runnable()
 16                 {
 17                     @Override
 18                     public void run()
 19                     {
 20                         for (int i = 1; i <= 50; i++)
 21                         {
 22                             core.SubMethod2(i);
 23                         }    
 24                     }
 25                 }
 26         ).start();
 27         
 28         //子线程3
 29         new Thread(
 30                 new Runnable()
 31                 {
 32                     @Override
 33                     public void run()
 34                     {
 35                         for (int i = 1; i <= 50; i++)
 36                         {
 37                             core.SubMethod3(i);
 38                         }    
 39                     }
 40                 }
 41         ).start();
 42         
 43         //主线程
 44         for (int i = 1; i <= 50; i++)
 45         {
 46             core.MainMethod(i);
 47         }
 48     }
 49     
 50     /**
 51      * 创建一个静态的类
 52      * 将核心的业务逻辑的方法放在这里
 53      * 体现了高内聚的特点
 54      * @author huang.jf
 55      */
 56     static class Core{
 57         //创建一个Lock锁对象
 58         public Lock lock = new ReentrantLock();
 59         //创建三个Condition对象 分别用于控制三个线程
 60         public Condition condition1 = lock.newCondition();
 61         public Condition condition2 = lock.newCondition();
 62         public Condition condition3 = lock.newCondition();
 63         //线程2   循环输出10次
 64         public void SubMethod2(int j){
 65             lock.lock();//开启Lock锁
 66             try{
 67                 //true 执行
 68                 //false 等待
 69                 while(HASOUT!=2){
 70                     try
 71                     {
 72                         condition2.await();//线程2等待
 73                     } catch (InterruptedException e)
 74                     {
 75                         e.printStackTrace();
 76                     }
 77                 }
 78                 //线程2执行
 79                 for (int i = 1; i <= 10; i++)
 80                 {
 81                     System.out.println("this is sub2 thread..."+i+"......."+j);
 82                 }
 83                     HASOUT = 3;
 84                     condition3.signal();//唤醒线程3
 85             }finally{
 86                 lock.unlock();//释放锁
 87             }
 88         }
 89         
 90         //线程3   循环输出20次
 91         public void SubMethod3(int j){
 92             lock.lock();//开启Lock锁
 93             try{
 94                 //true 执行
 95                 //false 等待
 96                 while(HASOUT!=3){
 97                     try
 98                     {
 99                         condition3.await();//线程3等待
100                     } catch (InterruptedException e)
101                     {
102                         e.printStackTrace();
103                     }
104                 }
105                 //线程3执行
106                 for (int i = 1; i <= 20; i++)
107                 {
108                     System.out.println("this is sub3 thread..."+i+"......."+j);
109                 }
110                     HASOUT = 1;
111                     condition1.signal();//唤醒线程1(主线程)
112             }finally{
113                 lock.unlock();//释放锁
114             }
115         }
116         
117         
118         //主线程调用循环输出一百次
119         public void MainMethod(int j){
120             lock.lock();
121             try{
122                 //false 执行
123                 //true 等待
124                 while(HASOUT!=1){
125                     try
126                     {
127                         condition1.await();//主线程等待
128                     } catch (InterruptedException e)
129                     {
130                         e.printStackTrace();
131                     }
132                 }
133                 //执行主线程
134                 for (int i = 1; i <= 100; i++)
135                 {
136                     System.out.println("this is main thread..."+i+"......"+j);
137                 }
138                     HASOUT = 2;
139                     condition2.signal();//唤醒线程2
140             }finally{
141                 lock.unlock();
142             }
143         }
144     }
145 }

输出结果可以自己尝试输出，指定到一个输出文件中，便于查看。