求高手指教：今天看到一题目：设计两个线程类，一个线程类负责打印100以内所有的偶数，另一个线程打印100以内所有的奇数。要求偶数线程每打印10个偶数以后，就让奇数线程打印10个奇数，如此交替进行。
我自己也找出一个只是很麻烦啊 求高手指教给出简单的可运行的程序，我的程序如下：

public class printThread extends Thread {

public static void main(String[] args) throws Exception {
CyclicBarrier barrier = new CyclicBarrier(2);
new printThread(barrier,true, 0).start();
new printThread(barrier,false, 1).start();
}

int numberic;
boolean isEven;
private CyclicBarrier barrier;
public printThread(CyclicBarrier barrier,boolean isEven, int numberic) {
this.barrier = barrier;
this.isEven = isEven; //true,双数打印;false,单数打印
this.numberic = numberic;//从什么值，开始连续打印50个双（单）数
}
public synchronized int printNumberic(int numberic) {
int count = 0;
if (isEven) {
System.out.print(“十个偶数是:”);
} else {
System.out.print(“十个奇数是:”);
}
while (count < 10) {
System.out.print(numberic + “,”);
numberic = numberic + 2;
count = count + 1;
}
return numberic;
}
public void run() {
try {
while (numberic < 100) {
if (!isEven){
sleep(2000);//先打印双数，利用sleep()做出时间间隔，后打印单数
}else{
sleep(1000);//为演示效果，控制打印双数的时间间隔
}
numberic = this.printNumberic(numberic);
System.out.println();
barrier.await();//使用barrier保证每打印一组双数和一组单数后，继续递增式打印
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}

public class ThreadTest {
        private  boolean flag=false;//判断一个线程是否执行完成
        private int odd_num=-1;//奇数
        private int even_num=0;//偶数
    /**
     * 输出奇数
     */
       
    public synchronized void printOdd()
    {
            if(odd_num>=99)
            {
            return;
            }
            try {
                        if(flag)
                        {
                                wait();
       
                        }
                        do
                        {
                                System.out.println("输出10个奇数");
                               
                        for(int i=1;i<=10;i++)
                        {
                               
                               
                                         odd_num+=2;
                                        System.out.print("i="+odd_num+"\t");
                                   
                                
                        }
                        System.out.println("\n"+"输出10个奇数结束");
                               flag=true;
                               notifyAll();               
                        }
                        while(!flag);
                       
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
            
    }
    /**
     * 输出偶数
     */
    public synchronized   void printEven()
    {
            if(even_num>=100)
            {
                    return;
            }
            try {
                        if(!flag)
                        {
                                wait();       
                        }
                do
                {
                        System.out.println("输出10个偶数");

                for(int i=1;i<=10 && even_num<100;i++)
                {
                            even_num+=2;
                        System.out.print("i="+even_num+"\t");
                        
                }
                System.out.println("\n"+"输出10个偶数结束");
                       flag=false;
                       notifyAll();       
                }
                while(flag);
                       
                       
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
   
    }
  public static void main(String[] args)
  {
          final ThreadTest tt=new ThreadTest();
          new Thread(new Runnable() {
               
                @Override
                public void run() {
                        // TODO Auto-generated method stub
                for(int i=0;i<5;i++)
                {
                        tt.printOdd();
                }
                       
                }
        }).start();
          new Thread(new Runnable() {
               
                @Override
                public void run() {
                        // TODO Auto-generated method stub
                        for(int i=0;i<5;i++)
                        {
                                tt.printEven();
                        }
                               
                }
        }).start();
  }
}

我又简化了一下，不知是否ok：

public class ThreadTest{
        private  boolean flag=false;//判断一个线程是否执行完一次任务
        private int odd_num=-1;//奇数
        private int even_num=0;//偶数
    public synchronized void printOdd()//输出奇数
    {
            try {
                        if(flag)
                        {
                                wait();
                        }
                        else       
                        {                               
                        for(int i=1;i<=10;i++)
                        {         
                        odd_num+=2;
                            System.out.print("i="+odd_num+"\t");                
                        }
                        System.out.println("\n");
                               flag=true;
                               notifyAll();               
                        }                               
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }          
    }
    public synchronized   void printEven()//输出偶数
    {
            try {
                        if(!flag)
                        {
                                wait();       
                        }
                        else
                        {
                                for(int i=1;i<=10;i++)
                        {
                                    even_num+=2;
                                System.out.print("i="+even_num+"\t");                
                        }
                                System.out.println("\n");
                               flag=false;
                               notifyAll();       
                        }                       
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }   
    }   
  public static void main(String[] args)
  {
          final ThreadTest tt=new ThreadTest();
          new Thread(new Runnable() {//打印奇数的线程
               
                @Override
                public void run() {
                        // TODO Auto-generated method stub
                        for(int i=0;i<5;i++)
                        {
                              tt.printOdd();
                        }
                }
        }).start();
          new Thread(new Runnable() {
                       
                        @Override
                        public void run() {//打印偶数的线程
                                // TODO Auto-generated method stub
                                for(int i=0;i<5;i++)
                                {
                                      tt.printEven();
                                }
                        }
                }).start();
  }         
}

陈科宇 发表于 2013-2-3 21:19
我又简化了一下，不知是否ok：

public class ThreadTest{

很不错.........