1. class Demo
   
2. {
   
3.         String name;
   
4.         String sex;
   
5. }
   
6. class Input implements Runnable
   
7. {        
   
8.         private Demo d;
   
9.         Input(Demo d)
   
10.         {
    
11.                 this.d=d;
    
12.         }
    
13.         public void run()
    
14.         {
    
15.                 while(true)
    
16.                 {
    
17.                         try
    
18.                         {
    
19.                                 Thread.sleep(20);
    
20.                         }
    
21.                         catch (Exception e)
    
22.                         {
    
23.                                 System.out.println(e.toString());
    
24.                         }
    
25.                         System.out.println(Thread.currentThread().getName()+"存bbbbbb");
    
26.                 }
    
27.         }
    
28. }
    
29. class Output implements Runnable
    
30. {
    
31.         private Demo d;
    
32.         Output(Demo d)
    
33.         {
    
34.                 this.d=d;
    
35.         }
    
36.         public void run()
    
37.         {
    
38.                 while(true)
    
39.                 {
    
40.                         try
    
41.                         {
    
42.                                 Thread.sleep(20);
    
43.                         }
    
44.                         catch (Exception e)
    
45.                         {
    
46.                                 System.out.println(e.toString());
    
47.                         }
    
48.                         System.out.println(Thread.currentThread().getName()+"取aaaaaaaaaaaaaaa");
    
49.                 }
    
50.         }
    
51. }
    
52. class Demo3
    
53. {
    
54.         public static void main(String[] args)
    
55.         {
    
56.                 Demo d = new Demo();
    
57.                 Output ou = new Output(d);
    
58.                 Input in = new Input(d);
    
59.                 Thread t1 = new Thread(in);
    
60.                 Thread t2 = new Thread(ou);
    
61.                 t1.start();
    
62.                 t2.start();
    
63.         }
    
64. }

复制代码

我这个需要同步吗？ 求详解 详解 详解 详解 详解 详解

如果你不同步，就会出显一个线程在存，一个线程在取，这2个线程之间没有任何关系。但你怎么知道是存一个取1个呢，还是存10个取1个呢。
当然你同步了，你也达不到存一个取一个的目的，你只需要定义一个变量用于切换2个线程就OK了
当然，你要不是想存一个取一个，那么你程序是OK的。

package com.it.test;

class Demo
{
        String name;
        String sex;
        boolean flag=false;
}
class Input implements Runnable
{        
        private Demo d;
        Input(Demo d)
        {
                this.d=d;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                Thread.sleep(20);
                        }
                        catch (Exception e)
                        {
                                System.out.println(e.toString());
                        }
                      synchronized(d){
                            while(d.flag){
                                   try{d.wait();}catch(Exception e){}
                        }
                                   System.out.println(Thread.currentThread().getName()+"存bbbbbb");
                                   d.flag = true;
                                   d.notify();
                        
                }
        }
}
}
class Output implements Runnable
{
        private Demo d;
        Output(Demo d)
        {
                this.d=d;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                Thread.sleep(20);
                        }
                        catch (Exception e)
                        {
                                System.out.println(e.toString());
                        }
                       synchronized(d){
                               while(!d.flag){
                                           try{d.wait();}catch(Exception e){}
                                }
                                           System.out.println(Thread.currentThread().getName()+"取aaaaaaaaaaaaaaa");
                                       d.flag = false;
                                       d.notify();
                        
                       }
               
        }
}
}
public class Demo3
{
        public static void main(String[] args)
        {
               
                Demo d = new Demo();
                Output ou = new Output(d);
                Input in = new Input(d);
                Thread t1 = new Thread(in);
                Thread t2 = new Thread(ou);
                t1.start();
                t2.start();
        }
}