Thread and Pipes problem.

[kunagu varun]

Write a multi-threaded Java program to print all numbers below 100,000 that are both prime and fibonacci number (some examples are 2, 3, 5, 13, etc.). Design a thread that generates prime numbers below 100,000 and writes them into a pipe. Design another thread that generates fibonacci numbers and writes them to another pipe. The main thread should read both the pipes to identify numbers common to both.

Hello ranchers please give an idea of how to implement above problem...

[Campbell Ritchie]

You need a program which finds Fibonacci numbers and one to find prime numbers.

Really! You didn't think we would produce your code or do your homework, did you?

You will have to show us what you have got already, and we'll tell you what we think of it.

[fred rosenberger]

start small. write a little code at a time. Every time I start a new program, I write exactly this much before I compile and test:

public class MyClass
{
    public static void main(String [] args)
   {
       System.out.println("In main");
   }
}

Once I'm sure that compiles and runs, I'll add a few more lines. Then I'd compile, test and debug those few lines.

[kunagu varun]

I feel sorry for my irregular post ranchers...
I have gathered some information regarding pipedIO and written the following code for my problem stated in the previous post..

Please have a look at this code..

  
import java.util.Timer;
import java.util.TimerTask;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.util.Random;
class Sender extends Thread 
 {
  private Random rand = new Random();
  private PipedWriter out = new PipedWriter();
  public PipedWriter getPipedWriter()
  {
    return out;
  }
  public void run() 
  {
    while (true)
	{
	int a=0;
	int b=1,i;
      for (i=1;i<10;i++)
	  {
        try
		{
          out.write(a);
		  out.write(b);
		  a=a+b;
		  b=a+b;
          sleep(rand.nextInt(500));
        } 
		catch (Exception e) 
		{
          throw new RuntimeException(e);
        }
      }
    }
  }
}

class Sender1 extends Thread 
{
  private Random rand1 = new Random();
  private PipedWriter out1 = new PipedWriter();
  public PipedWriter getPipedWriter() 
  {
    return out1;
  }

  public void run() 
  {
    while (true) 
	{
	int i;
      for (i=1;i<10;i++)
	  {
        try 
		{
		  int j;
  	      for (j=2; j<i; j++)
		  {
      		  int n = i%j;
     		   if (n==0)
			   {
      		    break;
      		   }
     	  }
      	if(i == j)
		  {
      	    out1.write(i);
     	  }   	       
	       sleep(rand1.nextInt(500));
        } 
		catch (Exception e) 
		{
          throw new RuntimeException(e);
        }
      }
    }
  }
}
class Receiver extends Thread
 {
  private PipedReader in;
  public Receiver(Sender sender) throws IOException
  {
    in = new PipedReader(sender.getPipedWriter());
  }
  public void run() 
  {
    try
	{
      while (true) 
	  {
        // Blocks until characters are there:
	   int[] a=new int[10];
	   for(int i=0;i<10;i++)
	   {
		 a[i]=in.read();
		 System.out.println(a[i]);
	   }
      }
	}
	catch (Exception e) 
	{
          throw new RuntimeException(e);
    }
  }
}
class Receiver1 extends Thread
 {
  private PipedReader in1;
  public Receiver1(Sender1 sender1) throws IOException 
 {
   in1 = new PipedReader(sender1.getPipedWriter());
 }
 public void run() 
  {
    try
	{
      while (true) 
	  {
        // Blocks until characters are there:
	   int[] b=new int[10];
	   for(int i=0;i<10;i++)
	   {
		 b[i]=in1.read();
		 System.out.println(b[i]);
	   }
      }
	}
	catch (Exception e) 
	{
          throw new RuntimeException(e);
    }
  }
 }
public class PipedIO 
{
  public static void main(String[] args) throws Exception
  {
    Sender sender = new Sender();
    Sender1 sender1 = new Sender1();
    Receiver receiver = new Receiver(sender);
    Receiver1 receiver1 = new Receiver1(sender1);
    sender.start();
	sender1.start();
    receiver.start();
    receiver1.start();
    new Timeout(4000, "Terminated");
  }
}
class Timeout extends Timer {
  public Timeout(int delay, final String msg) {
    super(true); // Daemon thread
    schedule(new TimerTask() {
      public void run() {
        System.out.println(msg);
        System.exit(0);
      }
    }, delay);
  }
} ///:~

The following is the output which i am getting..
0
1
1
2
2
3
3
5
5
7
8
13
21
34
55
89
144
233
377
610
987
1597
0
1
2
3
1
2
3
5
8
13
Terminated
5
7
21
34
55
89
144
233
377
610
987
1597
0
1
1
2

Please solve this issue..

[W. Joe Smith]

To me it looks like you are getting complicated when you don't need to. I thought this was an interesting problem, so I coded it earlier to see what I came up, after some research. I'd suggest making 3 classes: 1 that does the fibonacci numbers, one that figures the primes, and a third that will be used to compare the two. After you get those three classes functional, then I would look into integrating threads and pipes.

I suggest looking at this link, and the programs they designed.

[kunagu varun]

Thanks for the link.. I will try as you suggested and post back here later..