Need help in code regarding join()

[ashwin bhawsar]

Currently iam learning Threads topic from Kathy Sierra.
I am trying to write a typical producer-consumer code that makes use of the join() method of Thread.

This is what i want to accomplish :
1> There will be 3 threads Thread_A, Thread_B and Thread_C.

2> Thread_A's job is to continuously take input from the User from console and store it in an ArrayList.
The input will be in form of positive integer numbers ( eg: 2, 3, 100, 50 ....).

3> Thraed_B's job is to iterate through the array list and read these values one-by-one and store it in a variable.
Thraed_B will not read the next values unless Thread_C has finished its job.( Thread_B has join() on Thread_C)

4> Thread_C's job is to print '#' character in a File as per the values in the variable. So if the
values is say 20, then Thread_C will print '#' 20 times in the file.

To summarize, if the user has entered (20, 5, 10, 50) then Thread_C should print '#' 20 times, then 5 times then 10 times.....

I am not getting where to start the Thread_C.

import java.io.*;
import java.io.*;
import java.util.*;

//-------------- Thread_A: Take user input------------------
class UserThread implements Runnable {

	List<Integer> instructionList;

	UserThread(List<Integer> instructionList) {
		this.instructionList = instructionList;
	}

	// take an input from the user and ad it as an instruction
	public void takeUserInput() {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int instruction;
		try {
			instruction = Integer.parseInt(br.readLine());

			// Add the input to the ArrayList
			instructionList.add(instruction);

		} catch (IOException e) {
			e.printStackTrace();
		} catch (NumberFormatException e) {
			System.out.println("Please enter a number");
		}
	}

	public void run() {
		// continuously take user input in form of numbers
		while (true) {
			takeUserInput();
		}

	}
}

// ---------------Thread_B: Iterate the ArrayList-------------------
class ReadInstruction implements Runnable {
	static List<Integer> instructions;

	ReadInstruction(List<Integer> instructionList) {
		this.instructions = instructionList;
	}

	public void run() {
		WriteToFile m = new WriteToFile();
		//start the thread_C
		Thread thread_C = new Thread(m, "Thread_C");
		thread_C.start();

		while (true) {
			// Iterate
			for (int i = 0; i < instructions.size(); i++) {
				int instruction = instructions.get(i);

				// Store it so that thread_C can read it
				StorageClass.setValue(instruction);
				instructions.remove(i);
				try {
					// iterate to the next value of List only after Thread_C has
					// finished
					// its job.
					thread_C.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		}
	}
}

// ---------- Thread_C writes character '#' to File ----------------
class WriteToFile implements Runnable {

	BufferedWriter bf;

	WriteToFile() {
		try {
			File f = new File("c:/machineFile.txt");
			FileWriter fw = new FileWriter(f);
			bf = new BufferedWriter(fw);
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	public void run() {
		while(true){
			if(StorageClass.getValue()>0){
				try {
					bf.append("Loop count:" + StorageClass.getValue() + "\n");
					for (int i = StorageClass.getValue(); i > 0; i--) {
						bf.append("#");
					}			
					Thread.sleep(5000); //Sleep for some time.
					bf.append("\n");
					bf.flush();
					System.out.println("Written:" + StorageClass.getValue());
					StorageClass.setValue(0);
				} catch (IOException e) {
					e.printStackTrace();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

// --------- Thread_B stores value for Thread_C ---------------
class StorageClass {
	static int value;

	public static synchronized void setValue(int myValue) {
		value = myValue;
	}

	public static synchronized int getValue() {
		return value;
	}
}

// -------------- Main Class ---------------------------------
public class PracClass {

	static List<Integer> userInstruction = new ArrayList<Integer>();

	public static void main(String[] args) {

		// Thread_A for continuously getting the user input
		UserThread ut = new UserThread(userInstruction);
		Thread thread_A = new Thread(ut, "Thread_A");
		thread_A.start();

		// Thread_B for reading the instruction one by one and passing it to
		// machine
		ReadInstruction ri = new ReadInstruction(userInstruction);
		Thread thread_B = new Thread(ri, "Thread_B");
		thread_B.start();
	}

}

[ashwin bhawsar]

I want to keep thread_C running, but doing so thread_B will never move forward as thread_C's run is in while loop, so it will never die.

[ashwin bhawsar]

The approach was wrong. The solution to the problem can be achieved using the wait() and notify() methods.

I had put an infinite loop in Thread_C to continually monitor if the Thread_B has written some value, but doing so Thread_C was not exiting the run method and so not going "dead".
As Thread_B had join over Thread_C, Thread _B could not go further unless Thread_C was not over and this was not happening.

To achieve the goal i have used the wait() and notify() methods.
Below is a new code that will make clear how to achieve the goal using wait() and notify() methods.
( Note : The code now does not take any input from the user, instead the producer produce the values)

import java.io.*;

//Program : this program will crate 2 threads, Producer and a Consumer thread.
//The producer thread will iterate through a loop and write values to a common resouce
//which is then read by the consumer and written to the File. The producer will wait to produce
//the next value unless it gets the notification from the consumer thread.   

//Common resource will be shared between the Producer and Consumer threads
//Producer will write values to it and the consumer will consume values from it.
class CommonResource{
	private int value;
	
	public int getValue(){
		return value;
	}
	
	public void setValue(int v){
		this.value=v;
	}	
}

// Producer will run a loop through 0 to 50
class Producer implements Runnable{
	
	CommonResource resource;

	Producer(CommonResource commonResource){
		this.resource=commonResource;
	}
	
	public void run(){		
		for(int i=0;i<50;i++){
			synchronized (resource) {
				//iterate from 0 to 50 one-by-one and store it in a common resource
				resource.setValue(i);
				try{
					// wait till the consumer consumes the value and writes it to a file
					// i.e wait until we get notification from the consumer of the resource object 
					resource.wait(); 
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
		}		
	}	
}

class Consumer implements Runnable{
	
	CommonResource resource;
	File f;
	FileWriter fw;
	BufferedWriter bw;
	

	Consumer(CommonResource commonResource){
		this.resource=commonResource;
		try{
			// File to which the consumer will write the values it has consumed
			f = new File("C:/machinewriter.txt");
			fw = new FileWriter(f);
			bw = new BufferedWriter(fw);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public void run(){
		while(true){
			synchronized (resource) {				
				if(resource.getValue()!=0){
					try{
						System.out.println(resource.getValue());
						bw.write("\n Loop:"+resource.getValue());
						// Consume the value written by producer in the common resource object
						for(int i=0;i<resource.getValue();i++){
							bw.write("#");
						}
						bw.flush();
					}catch(IOException e){
						e.printStackTrace();
					}
					
				}
				//Notify to the producer that he value is consumed and written to the file
				resource.notify();
				resource.setValue(0);
			}
		}
	}	
}


public class ThreadClass{	
	public static void main(String[] args) {
		CommonResource commonResource = new CommonResource();
		
		//create the Prducer thread
		Producer producer = new Producer(commonResource);
		Thread producerThread = new Thread(producer,"PRODUCER");
		producerThread.start();
		
		//create the consumer thread
		Consumer consumer = new Consumer(commonResource);
		Thread consumerThread = new Thread(consumer,"CONSUMER");
		consumerThread.start();
	}
}