import java.util.Random;


public class MyMain {

        /**
         * @param args
         */
         int panZi = 0;
         Random random  = new Random();
         static MyMain mymain = new  MyMain();
        public static void main(String[] args) {
                mymain.a2();
        }
       
        public void a1(){
                int j=0;
                if(panZi==0){
                        j = random.nextInt(10);
                        if(j>0){
                                panZi  =panZi + j;
                                System.out.println("爸爸放了"+j+"个苹果");
                        }
                }
                mymain.a2();
        }
       
        public  void a2(){
                if(panZi>0){
                        System.out.println("爸爸等着孩子拿苹果");
                        System.out.println("孩子拿走一个苹果");
                        panZi--;
                }
                mymain.a1();
        }
}

类似于递归。。呵呵。。补充。。

这道题很有意思，a1调用a2，a2调用a1，互相调用。

在堆栈中两个方法互相调用，a1调用a2的时候在栈中开辟运行空间，a2调用a1时开辟运行空间，就是两个方法在互相调用对方不断的在堆中开辟内存空间，

根据盘子的随机数，来让执行a1方法，a1执行完毕后又开始调用a2，a2又给盘子一个随机数，然后又开始调用a1方法。

周而复始，最终导致堆栈内存溢出。

我是来蹭分的。。。

王_涛 发表于 2012-2-8 13:44
这是一个生产者和消费者的问题

实现代码如下：

对，就是这个。。看来我该晚上补补课了。。。╮(╯▽╰)╭

这是经典的消费者生产者的问题哦，本意就是考察线程的互斥同步嘛，get put方法中的while循环是为了防止出现假唤醒，当然用if也可以，老实说我自己做最多用if语句，绝对想不到用while，假唤醒的情况不是很熟悉。

这是一个生产者和消费者的问题

实现代码如下：

1. import java.util.Random;
   
2. 
   
3. public class ThreadApple {
   
4.         public static void main(String[] args) {
   
5.                 //创建一个盘子
   
6.                 Plate p = new Plate();
   
7.                 //创建两个线程并启动。
   
8.                 new Thread(new Father(p)).start();
   
9.                 new Thread(new Son(p)).start();
   
10.         }
    
11. }
    
12. 
    
13. //盘子
    
14. class Plate {
    
15.         private int num = 0;
    
16.         private Random ran = new Random();
    
17.         public synchronized void put() {
    
18.                 while(num > 0) {
    
19.                         try {
    
20.                                 this.wait();
    
21.                         } catch (InterruptedException e) {
    
22.                                 e.printStackTrace();
    
23.                         }
    
24.                 }
    
25.                 num = ran.nextInt(10);
    
26.                 System.out.println(Thread.currentThread().getName() + "爸爸向盘子里放了" + num + "个苹果");
    
27.                 this.notify();
    
28.         }
    
29.         public synchronized void get() {
    
30.                 while(num == 0) {
    
31.                         try {
    
32.                                 this.wait();
    
33.                         } catch (InterruptedException e) {
    
34.                                 e.printStackTrace();
    
35.                         }
    
36.                 }
    
37.                 num--;
    
38.                 System.out.println(Thread.currentThread().getName() + "孩子从盘子里取出一个苹果，盘子里还剩下" + num + "个苹果");
    
39.                 this.notify();
    
40.         }
    
41. }
    
42. 
    
43. //爸爸线程，向盘子里放苹果。
    
44. class Father implements Runnable {
    
45.         private Plate p;
    
46.         public Father(Plate p) {
    
47.                 this.p = p;
    
48.         }
    
49.         public void run() {
    
50.                 while(true) {
    
51.                         p.put();
    
52.                 }
    
53.         }
    
54. }
    
55. 
    
56. //孩子线程，从盘子里取苹果。
    
57. class Son implements Runnable {
    
58.         private Plate p;
    
59.         public Son(Plate p) {
    
60.                 this.p = p;
    
61.         }
    
62.         public void run() {
    
63.                 while(true) {
    
64.                         p.get();
    
65.                 }
    
66.         }
    
67. }

复制代码

李泽霖 发表于 2012-2-8 11:31
这是我做的，参照一下
class Testapples
{

用多线程做的思路不错，要是能father放一个child哪一个就更好了

这是我做的，参照一下
class Testapples
{
public static void main(String[] args)
{
apples a = new apples(100);
new Father(a).start();
new Children(a).start();
}
}
class apples
{
int number=0;
int size;
public apples(int size)
{
this.size = size;
}
boolean available=false;
}



class Father extends Thread
{
apples a = null;
public Father(apples a)
{
this.a = a;
}
public void run()
{
while (a.number < a.size)
{
System.out.println("father puts apples"+(++a.number));
a.available=true;
}
}
}


class Children  extends Thread
{
apples a=null;
int i=0;
public Children(apples a)
{
this.a = a;
}
public void run()
{
while(i<a.size)
{
if(a.available==true && i<a.number)
System.out.println("children get apples"+(++i));
if(i==a.number)
a.available=false;
}
}
}


class Father extends Thread
{
apples a = null;
public producer(apples a)
{
this.a = a;
}
public void run()
{
while (a.number < a.size)
{
System.out.println("procdure puts ticket"+(++t.number));
a.available=true;
}
}
}


class Children  extends Thread
{
apples a=null;
int i=0;
public consumer(apples a)
{
this.a = a;
}
public void run()
{
while(i<a.size)
{
if(a.available==true && i<a.number)
System.out.println("consumer buys ticket"+(++i));
if(i==a.number)
a.available=false;
}
}
}

这是我做的，参照一下
class Testapples
{
public static void main(String[] args)
{
apples a = new apples(100);
new Father(a).start();
new Children(a).start();
}
}
class apples
{
int number=0;
int size;
public apples(int size)
{
this.size = size;
}
boolean available=false;
}



class Father extends Thread
{
apples a = null;
public Father(apples a)
{
this.a = a;
}
public void run()
{
while (a.number < a.size)
{
System.out.println("father puts apples"+(++a.number));
a.available=true;
}
}
}


class Children  extends Thread
{
apples a=null;
int i=0;
public Children(apples a)
{
this.a = a;
}
public void run()
{
while(i<a.size)
{
if(a.available==true && i<a.number)
System.out.println("children get apples"+(++i));
if(i==a.number)
a.available=false;
}
}
}


class Father extends Thread
{
apples a = null;
public producer(apples a)
{
this.a = a;
}
public void run()
{
while (a.number < a.size)
{
System.out.println("procdure puts ticket"+(++t.number));
a.available=true;
}
}
}


class Children  extends Thread
{
apples a=null;
int i=0;
public consumer(apples a)
{
this.a = a;
}
public void run()
{
while(i<a.size)
{
if(a.available==true && i<a.number)
System.out.println("consumer buys ticket"+(++i));
if(i==a.number)
a.available=false;
}
}
}

原题是这样的：
一个爸爸，一个盘子，一个孩子，当盘子是空时，孩子不能拿苹果，爸爸会往里放苹果；当盘子有苹果时，爸爸不能放苹果，孩子每次取一个苹果
盘子空时，孩子只能等着爸爸放好苹果后才能去拿

盘子为空的时候爸爸才能放苹果
保证儿子每次都能拿到苹果

你这个程序貌似会无限循环下去吧，内存泄漏不就是程序执行完毕，内存中的资源没有被回收吗？