输出1到10的整数
有2个函数，一个输出奇数，一个输出偶数
        public static int printOdd(int i) {
                if (i % 2 == 1) {
                        System.out.println(i);
                        return ++i;
                }
                return i;
        }

        public static int printEven(int i) {
                if (i % 2 == 0) {
                        System.out.println(i);
                        return ++i;
                }
                return i;
        }
用一个线程调用输出奇数的函数，输出后等待另一线程调用输出偶数函数，循环直到10完成，2个线程结束.如何实现?想了半天想不出来，请指教!
用2个线程调用以上的函数。线程要通信，输出结要为:1 2 3 4 5 6 7 8 9 10然后2个线程结束

黄鸿达 发表于 2013-2-4 16:42
你看这样满意不？我是以你给的函数为基础 ，加代码的。2个线程各自调用你所给个不同函数。那些中文字对象， ...

哦，谢了，我也好了

1. import java.util.concurrent.locks.*;
   
2. 
   
3. 
   
4. public class Th {
   
5. static void show(Object obj){
   
6. System.out.println("你要的数:-------------------------"+obj);
   
7. }
   
8. public static void main(String[] args) {
   
9. 奇数 j=new 奇数();
   
10. 偶数 o=new 偶数();
    
11. Thread t1=new Thread(j);
    
12. Thread t2=new Thread(o);
    
13. t1.start();
    
14. // try {Thread.sleep(100);} catch (InterruptedException e) {}
    
15. t2.start();
    
16. }
    
17. 
    
18. }
    
19. class Data{
    
20. public static int num=1;
    
21. Data(){
    
22. }
    
23. 
    
24. }
    
25. class Lock{
    
26. static ReentrantLock lock=new ReentrantLock();
    
27. static Condition 偶数监视=lock.newCondition();
    
28. static Condition 奇数监视=lock.newCondition();
    
29. }
    
30. class 奇数 implements Runnable{
    
31. private Data d;
    
32. public static int printOdd(int i) {
    
33. // System.out.println(Thread.currentThread()+"~~~从线程1传入"+i+"~~~");
    
34. // System.out.println("此时num的数值为"+i);
    
35. if (i % 2 == 1) {
    
36. Th.show(i);
    
37. // System.out.println(Thread.currentThread()+"---第"+i+"次---");
    
38. // System.out.println(Thread.currentThread()+"---将从线程0传出"+(i+1)+"---");
    
39. return ++i;
    
40. }
    
41. return i;
    
42. }
    
43. public void run(){
    
44. while(Data.num!=11)
    
45. {
    
46. Data.num=printOdd(Data.num);
    
47. try {
    
48. Lock.lock.lock();
    
49. // System.out.println("线程1获取锁定\n");
    
50. Lock.偶数监视.signal();
    
51. // System.out.println("将对线程2叫醒\n");
    
52. Lock.奇数监视.await();
    
53. // System.out.println("线程1要sleep\n"+Data.num);
    
54. if(Data.num==11){
    
55. Lock.偶数监视.signal();}
    
56. 
    
57. } catch (InterruptedException e) {
    
58. }
    
59. finally{
    
60. Lock.lock.unlock();
    
61. // System.out.println("线程1解锁 线程2\n"+Data.num);
    
62. }
    
63. }
    
64. }
    
65. }
    
66. class 偶数 implements Runnable{
    
67. public static int printEven(int i) {
    
68. // System.out.println(Thread.currentThread()+"~~~从线程0传入"+i+"~~~");
    
69. // System.out.println("此时num的数值为"+i);
    
70. if (i % 2 == 0) {
    
71. Th.show(i);
    
72. // System.out.println(Thread.currentThread()+"---第"+i+"次---");
    
73. // System.out.println(Thread.currentThread()+"---将从线程1传出"+(i+1)+"---");
    
74. return ++i;
    
75. }
    
76. return i;
    
77. }
    
78. public void run(){
    
79. while(Data.num!=11)
    
80. {
    
81. Data.num=printEven(Data.num);
    
82. try {
    
83. Lock.lock.lock();
    
84. // System.out.println("线程2获取锁定\n");
    
85. Lock.奇数监视.signal();
    
86. // System.out.println("将对线程1叫醒\n");
    
87. Lock.偶数监视.await();
    
88. // System.out.println("线程2要sleep\n"+Data.num);
    
89. if(Data.num==11){
    
90. Lock.奇数监视.signal();}
    
91. 
    
92. } catch (InterruptedException e) {
    
93. }
    
94. finally{
    
95. Lock.lock.unlock();
    
96. // System.out.println("线程2解锁 线程1\n"+Data.num);
    
97. }
    
98. }
    
99. }
    
100. }
     

复制代码

你看这样满意不？我是以你给的函数为基础 ，加代码的。2个线程各自调用你所给个不同函数。那些中文字对象，我是省得弄混，才写中文，调试如果不能识别中文自己改。

遇到的问题1：一开始写没加while循环 导致每个奇数 偶数 只算一次没了
后来再主程序+了while循环把t1.start t2.start括起来，发生IllegalThreadStateException，原来是我多次调用start方法了

遇到的问题2：后来在个线程run里面加上while后，数据错乱
然后加入了锁，但是之后出现IllegalMonitorStateException

遇到的问题3：后来baidu，原来监视器都是都是同一个，接着NEW 了2个Condition监视器后，可以了。但是算出10后，程序没停掉，找了半天不知道怎么回事。
后来才知道是线程2在睡觉，因为数已经到10 不循环，所以也没人叫醒线程2，后来加个if语句判断是否到11，到了就叫醒。

不要意思，我没有看清楚你的要求，其实道理是一样的。两个线程控制一个变量递减，我就不贴出代码了。

李挺 发表于 2013-2-3 19:31
结果是
Thread-0----10
Thread-1----9

你是多线程调用同一函数输出

输出1到10的整数
有2个函数，一个输出奇数，一个输出偶数
        public static int printOdd(int i) {
                if (i % 2 == 1) {
                        System.out.println(i);
                        return ++i;
                }
                return i;
        }

        public static int printEven(int i) {
                if (i % 2 == 0) {
                        System.out.println(i);
                        return ++i;
                }
                return i;
        }
用一个线程调用输出奇数的函数，输出后等待另一线程调用输出偶数函数，循环直到10完成，2个线程结束.如何实现?想了半天想不出来，请指教!
用2个线程调用以上的函数。线程要通信，输出结要为:1 2 3 4 5 6 7 8 9 10然后2个线程结束

陈科宇 发表于 2013-2-3 18:49
public class ThreadTest {
        private  boolean flag;//判断一个线程是否执行完成
    /**

你是2个线程一个输出奇数一个输出偶数，但2个线程没有通信，我是想2个线程通信输出为:1 2 3 4 5 6 7 8 9 10

以上都不是我想要的，谢了

1. class Shu
   
2. {
   
3.         int i=10;  //把十共有出来
   
4. }
   
5. class Shuchu implements Runnable
   
6. {
   
7.         private Shu s;
   
8.         Shuchu(Shu s) //导入1十
   
9.         {
   
10.                 this.s=s;
    
11.         }
    
12.         public void run()
    
13.         {
    
14.                 while (s.i>0)
    
15.                 {
    
16.                         synchronized(s)  //同步
    
17.                         {
    
18.                                 System.out.println(Thread.currentThread().getName()+"----"+s.i--);
    
19.                                 s.notify();  //唤醒别人
    
20.                                 try{s.wait();}catch(Exception e){}//冻结自己
    
21.                                 if (s.i<=0) s.notifyAll(); //循环结束后，唤醒冻结的进程以中止进程
    
22.                         }
    
23.                 }
    
24.                
    
25.         }
    
26. }
    
27. 
    
28. class  Demo09
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 Shu s=new Shu();
    
33.                 Shuchu j=new Shuchu(s);
    
34.                 Shuchu o=new Shuchu(s);
    
35.                 Thread t1=new Thread(j);
    
36.                 Thread t2=new Thread(o);
    
37.                 t1.start();
    
38.                 t2.start();
    
39.         }
    
40. }
    

复制代码

结果是
Thread-0----10
Thread-1----9
Thread-0----8
Thread-1----7
Thread-0----6
Thread-1----5
Thread-0----4
Thread-1----3
Thread-0----2
Thread-1----1
应该是你要的吧

开始输出奇数
1        3        5        7        9       
输出奇数结束
开始输出偶数
2        4        6        8        10       
输出偶数结束

public class ThreadTest {
        private  boolean flag;//判断一个线程是否执行完成
    /**
     * 输出奇数
     */
    public synchronized void printOdd()
    {
            System.out.println("开始输出奇数");

     for(int i=1;i<=10;i++)
     {
             if(i%2==1)
             {
                     System.out.print(i+"\t");
             }
             
     }
     System.out.println("\n"+"输出奇数结束");
         flag=true;
         notifyAll();
    }
    /**
     * 输出偶数
     */
    public synchronized   void printEven()
    {
            //如果奇数没有输出完成，输出偶数的线程必须等待
            if(!flag)
            {
                    try {
                                wait();
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
            }
            else{
                    System.out.println("开始输出偶数");
                    for(int i=1;i<=10;i++)
            {
                    if(i%2==0)
                    {
                            System.out.print(i+"\t");
                    }
            }       
                    System.out.println("\n"+"输出偶数结束");

            }
           
    }
  public static void main(String[] args)
  {
          final ThreadTest tt=new ThreadTest();
          new Thread(new Runnable() {
               
                @Override
                public void run() {
                        // TODO Auto-generated method stub
                        tt.printOdd();
                }
        }).start();
          new Thread(new Runnable() {
               
                @Override
                public void run() {
                        // TODO Auto-generated method stub
                        tt.printEven();
                }
        }).start();
  }
}