这是毕老师在视频提的一个例子  用synchronized解决多线程安全问题  
他说用单例设计模式也可以  但我试了几回都不对  求大神帮解决

1. 
   
2. class Res{
   
3.         String name;
   
4.         String sex;
   
5. }
   
6. class Input implements Runnable{
   
7.         private Res r;
   
8.         public  Input(Res r){
   
9.                 this.r = r;
   
10.         }
    
11.         public void run(){
    
12.                 int x =0;
    
13.                 while(true){
    
14.                         synchronized(r){
    
15.                                 if(x==0){
    
16.                                         r.name = "mike";
    
17.                                         r.sex = "男";
    
18.                                 }else{
    
19.                                         r.name = "lily";
    
20.                                         r.sex = "女";
    
21.                                 }
    
22.                                
    
23.                         }
    
24.                         x = (x+1)%2;
    
25.                 }
    
26.         }
    
27. }
    
28. class Output implements Runnable{
    
29.         private Res r;
    
30.         public Output(Res r){
    
31.                 this.r = r;
    
32.         }
    
33.         public void run(){
    
34.                 while(true){
    
35.                         synchronized(r){
    
36.                                 System.out.println(r.name+"---"+r.sex);
    
37.                         }
    
38.                 }
    
39.         }
    
40. }
    
41. public class InputOutputDemo01 {
    
42. 
    
43.         public static void main(String[] args) {
    
44.                 Res r = new Res();
    
45.                
    
46.                 Input in = new Input(r);
    
47.                 Output out = new Output(r);
    
48.        
    
49.                 Thread t1 = new Thread(in);
    
50.                 Thread t2 = new Thread(out);
    
51.                 t1.start();
    
52.                 t2.start();
    
53.         }
    
54. }
    

复制代码

1. 
   
2. <P>class test
   
3. {
   
4.         public static void main(String[] args){
   
5.                 new Thread(new input()).start();
   
6.                 new Thread(new output()).start();
   
7.         }
   
8. }
   
9. 
   
10. class input implements Runnable
    
11. {
    
12.         person p=person.getInstance();
    
13.         public void run(){
    
14.                  int x =0;
    
15.                 while(true){
    
16.                                 synchronized(p){
    
17.                                         if(x==0){
    
18.                                                         p.name = "张三";
    
19.                                                         p.sex = "男";
    
20.                                         }else{
    
21.                                                         p.name = "lili";
    
22.                                                         p.sex = "女";
    
23.                                         }
    
24.                                 }
    
25.                         x = (x+1)%2;
    
26.                 }
    
27.         }
    
28. }
    
29. class output implements Runnable
    
30. {
    
31.         person p=person.getInstance();
    
32.         public void run(){
    
33.                 while(true){
    
34.             synchronized(p){
    
35.                    System.out.println(p.name+"---"+p.sex);
    
36.             }
    
37.         }
    
38.         }
    
39. }</P>
    
40. <P> </P>
    
41. <P>//所谓的单例
    
42. class person
    
43. {</P>
    
44. <P>        //将该类的构造方法私有
    
45.         private person(){}</P>
    
46. <P>      //在本类中创建一个本类的对象
    
47.         private static person p=new person();</P>
    
48. <P>     //定义静态方法 返回上面创建的本类对象 即使这个方法被多次调用 返回的也只是在本类中创建的这个对象 保证了唯一性
    
49.         public static person getInstance(){
    
50.                 return p;
    
51.         }
    
52.         String name;
    
53.         String sex;
    
54. }</P>

复制代码

你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题

几番意难相付 发表于 2014-1-14 20:27

你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题

线程同步好像必须用到synchronized或者Lock,老师说的单例模式应该是指输入输出共同操作的资源吧?你倒回去仔细看看视频?

长石 发表于 2014-1-15 09:31
你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题 ...

那是你会错意了，毕老的意思并不是说单例可以代替同步，而是说，单例可以保证一个对象在内存中的唯一性。
原例中说，是让两个线程共同操作同一个资源。着重点是“同一个资源”，而不是同步。
然后学生说，用单例。这时候的语境，是相当于“同一个资源”而言的，并不是说，单例能解决线程安全。
然后毕老说，用单例可以，但是单例麻烦。他用的是在主函数中创建一个资源的对象，然后将这一个资源对象，作为参数传递给不同的线程执行操作。这样，多个线程操作的，只能是在主函数里建立的那唯一一个资源对象。
单例，上面说了，保证了对象在内存中的唯一性。也就相当于在主函数里建立一个对象分别给不同的线程操作。


线程安全问题，只能用同步，别无他法。要么synchronized，要么lock，再没有什么能够代替这两个。

几番意难相付 发表于 2014-1-15 10:29
那是你会错意了，毕老的意思并不是说单例可以代替同步，而是说，单例可以保证一个对象在内存中的唯一性。 ...

谢谢耐心解答

这么长，啊，看不下去。。。。。。。