/*
需求：开启2条线程, 轮流执行打印操作, 执行结果如下:
线程1: 1
线程1: 2
线程1: 3
线程2: 4
线程2: 5
线程2: 6
线程1: 7
线程1: 8
线程1: 9
线程2: 10
线程2: 11
线程2: 12
线程1: 13
线程1: 14
线程1: 15
线程2: 16
线程2: 17
线程2: 18

以上需求执行代码如下，结果如图：
*/
public class Work {
public static void main(String[] args){
  
  final HomeWork h=new HomeWork();
  new Thread(){
   public void run(){
    for(int i=0;i<3;i++)
     h.haha();
   }
  }.start();
  
  new Thread(){
   public void run(){
    for(int i=0;i<3;i++)
     h.hah();
   }
  }.start();
}
}
class HomeWork {
private int x = 1;
private int flag = 1;
public synchronized void haha() {
  if (flag == 2) {
   try {
    wait();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  System.out.println("线程1:" + x++);
  System.out.println("线程1:" + x++);
  System.out.println("线程1:" + x++);
  System.out.println();
  flag = 2;
  notify();
}
public synchronized void hah() {
  if (flag == 1) {
   try {
    wait();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
   
  System.out.println("线程2:" + x++);
  System.out.println("线程2:" + x++);
  System.out.println("线程2:" + x++);
  System.out.println();
   
  flag=1;
  notify();
}
}

/*
但怎样能开启3条或者更多线程执行呢？
如：

线程1: 1
线程1: 2
线程1: 3

线程2: 4
线程2: 5
线程2: 6

线程3: 7
线程3: 8
线程3: 9

线程1: 10
线程1: 11
线程1: 12

线程2: 13
线程2: 14
线程2: 15

线程3: 16
线程3: 17
线程3: 18
.
.
.
*/

这个好办！判断一下就行。然后需要实现LOCK接口，JDK升级已经把这个问题解决简单话。

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

public class Workkk {
        public static void main(String[] args) {

                final HomeWorkee h = new HomeWorkee();
                new Thread() {
                        public void run() {
                                for (int i = 0; i < 3; i++)
                                        try {
                                                h.haha();
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                        }
                }.start();

                new Thread() {
                        public void run() {
                                for (int i = 0; i < 3; i++)
                                        try {
                                                h.hah();
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                        }
                }.start();
               
                new Thread() {
                        public void run() {
                                for (int i = 0; i < 3; i++)
                                        try {
                                                h.ha();
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                        }
                }.start();
        }
        
}

class HomeWorkee {
        private int x = 1;
        private int flag = 3; //标记为3，只能最先执行线程1

        
        private Lock lock = new ReentrantLock(); // 实现锁的接口
        /**
         * 定义3个Condition
         */
        private Condition condition_1 = lock.newCondition();
        private Condition condition_2 = lock.newCondition();
        private Condition condition_3 = lock.newCondition();
        
        public  void hah()throws InterruptedException {
                lock.lock();
                try {
                if (flag == 1 ) {
                        
                        condition_1.await();//线程1等待
                }

                System.out.println("线程1:" + x++);
                System.out.println("线程1:" + x++);
                System.out.println("线程1:" + x++);
                System.out.println();

                flag = 1;
                condition_2.signal();//唤醒线程2
                }finally{
                        lock.unlock();
                }
        }
        
        public  void haha() throws InterruptedException{
                lock.lock();
                try {
                if (flag == 2 || flag == 3) {//flag初始值为3抢到资源也不会执行
                        condition_2.await();
                }
                System.out.println("线程2:" + x++);
                System.out.println("线程2:" + x++);
                System.out.println("线程2:" + x++);
                System.out.println();
                flag = 2;//置为2
                condition_3.signal();//唤醒线程3
                } finally {
                        lock.unlock();
                }
        }
        
        public  void ha() throws InterruptedException {
                lock.lock();
                try {
                if (flag == 3 || flag == 1) {
                        condition_3.await();
               
                }

                System.out.println("线程3:" + x++);
                System.out.println("线程3:" + x++);
                System.out.println("线程3:" + x++);
                System.out.println();

                flag = 3;
                condition_1.signal();//唤醒线程1
                }finally{
                        lock.unlock();
                }
        }
        file:///C:/Users/RC/Desktop/6666666666666.png

THANKS,解决了。
通过使用同步和通信也可以实现了，只要把if语句改成while语句，实现重复判断唤醒就可以了。你这个方法也“笑纳“了哈