1. /* 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
2. 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
   
3. 编程解决猫狗鱼过河问题。
   
4. 
   
5. 思路：
   
6. 1 第一想法是用多线线程解决
   
7. 2 创建动物类和农夫类，然后建立了狗猫鱼的类，动物类中有一个过河的方法，然后用狗猫鱼类集成动物类 并实现过河的方法
   
8. 3 创建了一个过河的类实现Runnable接口，通过构造函数接受一个动物的实例，然后在run方法中调用过河方法
   
9. 
   
10. 问题是 我加了同步代码块 也实现不了同步 应该是哪里出问题 请各位帮我解答！
    
11. */
    
12. class text
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 //创建了3个线程并启动
    
17.                 Thread t2 = new Thread(new goStream(new Cat()));
    
18.                 Thread t3 = new Thread(new goStream(new Dog()));
    
19.                 Thread t4 = new Thread(new goStream(new Fish()));
    
20.                 t2.start();
    
21.                 t3.start();
    
22.                 t4.start();
    
23.         }
    
24. }
    
25. class goStream implements Runnable
    
26. {
    
27.         private Animet a;//创建了动物对象用来接收构造函数传进的动物实例
    
28.         private Framer f= new Framer();//农夫实例
    
29.         Object obj = new Object();//锁
    
30.         goStream(Animet a)
    
31.         {
    
32.                 this.a = a;
    
33.         }
    
34.         public void run()
    
35.         {
    
36.                 synchronized(obj)//同步代码
    
37.                 {
    
38.                         //让任意一种动物和农夫过河
    
39.                         a.play();
    
40.                         f.play();
    
41.                         System.out.println("-----------");
    
42.                 }               
    
43.         }               
    
44. }
    
45. //类和方法我都写的比较简陋
    
46. class Animet
    
47. {        
    
48.         void play()
    
49.         {
    
50.                 System.out.println("动物过河");
    
51.         }
    
52. }
    
53. class Framer
    
54. {        
    
55.         void play()
    
56.         {
    
57.                 System.out.println("农夫过河");
    
58.         }
    
59. }
    
60. class Cat extends Animet
    
61. {
    
62.         void play()
    
63.         {
    
64.                 System.out.println("猫过河");
    
65.         }
    
66. }
    
67. class Dog extends Animet
    
68. {
    
69.         void play()
    
70.         {
    
71.                 System.out.println("狗过河");
    
72.         }
    
73. }
    
74. class Fish  extends Animet
    
75. {        
    
76.         void play()
    
77.         {
    
78.                 System.out.println("鱼过河");
    
79.         }
    
80. }

复制代码

不是同一个锁
我把你的同步锁 改成了 aaa.bbb

1. class text
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //创建了3个线程并启动
   
6.                                 //goStream gs=new goStream();
   
7.                 Thread t2 = new Thread(new goStream(new Cat()));
   
8.                 Thread t3 = new Thread(new goStream(new Dog()));
   
9.                 Thread t4 = new Thread(new goStream(new Fish()));
   
10.                 t2.start();
    
11.                 t3.start();
    
12.                 t4.start();
    
13.         }
    
14. }
    
15. 
    
16. class aaa
    
17. {
    
18.          static Object bbb=new Object();
    
19. }
    
20. class goStream implements Runnable
    
21. {
    
22.         private Animet a;//创建了动物对象用来接收构造函数传进的动物实例
    
23.         private Framer f= new Framer();//农夫实例
    
24.         Object obj = new Object();//锁
    
25.         goStream(Animet a)
    
26.         {
    
27.                 this.a = a;
    
28.         }
    
29.         public void run()
    
30.         {
    
31.                 synchronized(aaa.bbb)//同步代码
    
32.                 {
    
33.                         //让任意一种动物和农夫过河
    
34.                         a.play();
    
35.                         f.play();
    
36.                         System.out.println("-----------");
    
37.                 }               
    
38.         }               
    
39. }
    
40. //类和方法我都写的比较简陋
    
41. class Animet
    
42. {        
    
43.         void play()
    
44.         {
    
45.                 System.out.println("动物过河");
    
46.         }
    
47. }
    
48. class Framer
    
49. {        
    
50.         void play()
    
51.         {
    
52.                 System.out.println("农夫过河");
    
53.         }
    
54. }
    
55. class Cat extends Animet
    
56. {
    
57.         void play()
    
58.         {
    
59.                 System.out.println("猫过河");
    
60.         }
    
61. }
    
62. class Dog extends Animet
    
63. {
    
64.         void play()
    
65.         {
    
66.                 System.out.println("狗过河");
    
67.         }
    
68. }
    
69. class Fish  extends Animet
    
70. {        
    
71.         void play()
    
72.         {
    
73.                 System.out.println("鱼过河");
    
74.         }
    
75. }

复制代码

C:\Users\Administrator\Desktop\java笔记\java>javac text.java

C:\Users\Administrator\Desktop\java笔记\java>java text
猫过河
农夫过河
-----------
狗过河
农夫过河
-----------
鱼过河
农夫过河
-----------



是要这个结果吗？

这题明明就是用集合解，怎么会想出多线程的解法啊。

liuch111 发表于 2015-8-13 12:20

蛋疼死了~ 谢谢啦

kenfans 发表于 2015-8-13 13:34
这题明明就是用集合解，怎么会想出多线程的解法啊。

Map集合存起来？然后再遍历输出？

pengbeilin 发表于 2015-8-13 14:35
Map集合存起来？然后再遍历输出？

他的意思是要你用编程的方式，写出过河的方法。就是用集合的方式判断一个集合中，狗和猫是否同时存在，猫和鱼是否同时存在。河两边用两个集合代替，然后循环判断。农夫基本可以不用管。说明白一点就是：

河这边是集合A，河那边是集合B。
现在集合A扔一个动物给集合B，然后判断集合A是不是同时有狗和猫或者猫和鱼。如果有，过河失败，这个动物就不给B，如果没有。就把这个动物给B，再判断集合B。
集合B也和集合A一样，扔一个动物给集合A。也可以不扔。
每次过河有几种选择，自己集合里的某一个动物扔另一集合，或者不扔。
用for语句嵌套循环就行了。直到集合A的size是0，就过河成功了。这就是代码的思路

liuch111 发表于 2015-8-13 12:20

aaa.bbb是什么意思啊

同步搞死人

是这样的，你这里的OBJ锁每个线程的对象建立的时候都建立了一个新的OBJ锁，等于每个线程都拥有自己一个独立的锁。可以在goStream内将OBJ定义为静态的，这样OBJ只会加载一次，也就是说每个线程使用的锁都变成同一个了！或者在goStream外重新定义一个锁

如果要解题的话，思路应该是用 list集合去解，考的不是多线程

1. import java.util.ArrayList;
   
2. 
   
3. public class Test10crossriver {
   
4.         
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 new Test10crossriver().tohere();
   
8.         }
   
9.                 //创建一个集合，代表起始点.
   
10.                 ArrayList<String> here = new ArrayList<String>();
    
11.                 //创建一个集合，代表终点.
    
12.                 ArrayList<String> there = new ArrayList<String>();
    
13.                 //添加元素.
    
14.                 public Test10crossriver()
    
15.                 {
    
16.                         here.add("Dog");
    
17.                         here.add("cat");
    
18.                         here.add("fish");
    
19.                 }
    
20.                 //定义一个方法，用来判断这三个动物之间关系.
    
21.                 public boolean isSafe(ArrayList<String> al)
    
22.                 {
    
23.                         if (al.contains("dog") && al.contains("cat")|| al.contains("cat") && al.contains("fish"))
    
24.                         {
    
25.                                 return false;
    
26.                         }
    
27.                         return true;
    
28.                 }
    
29.                 //定义一个方法，将起点的元素送到终点.
    
30.                 public void tohere() {
    
31.                         String str = here.get(0);
    
32.                         here.remove(str);
    
33.                         if (isSafe(here)) {
    
34.                                 System.out.println("1农夫带着" + str + "去往对岸，这边还剩下" + here + ",对岸有" + there);
    
35.                                 toThere(str);
    
36.                         } else {
    
37.                                 here.add(str);
    
38.                                 tohere();
    
39.                         }
    
40.                 }
    
41.                 //定义一个方法，用来查看终点的元素.
    
42.                 public void toThere(String s) {
    
43. 
    
44.                                 there.add(s);
    
45.                             //如果here没有元素，表示已经成功并结束程序
    
46.                                 if(here.isEmpty()){
    
47.                                         System.out.println("4农夫，"+there+"都被你带过来了");
    
48.                                         return;
    
49.                                 }
    
50.                             //如果对岸安全，则农夫独自回到本岸，否则带上集合中第一个动物回到本岸
    
51.                                 if(isSafe(there)){
    
52.                                         System.out.println("2农夫回到原点,对岸有" + there);
    
53.                                         tohere();
    
54.                                 }else{
    
55.                                         String temp=there.get(0);
    
56.                                         there.remove(temp);
    
57.                                         System.out.println("3农夫带着"+temp+"回到原点，这边有" + here + ",对岸有" + there);
    
58.                                         here.add(temp);
    
59.                                         tohere();
    
60.                                 }
    
61.                 }
    
62. }

复制代码

呵呵　．　．．　．　　　

想透脑筋的题目

话说这个真的是基础题么？？

liuch111 发表于 2015-8-13 19:37
如果要解题的话，思路应该是用 list集合去解，考的不是多线程

受教了 谢谢

周博文 发表于 2015-8-13 21:31
话说这个真的是基础题么？？

是一个基础题~ 不过我没做

这个题，有点绕

kenfans 发表于 2015-8-13 16:08
他的意思是要你用编程的方式，写出过河的方法。就是用集合的方式判断一个集合中，狗和猫是否同时存在，猫 ...

果然，我也是这个题。