Java Tutorial #11 Using Pipes and Synchronized to read and write data
java·@nicetea·
0.000 HBDJava Tutorial #11 Using Pipes and Synchronized to read and write data
**Previous tutorial** https://steemit.com/java/@nicetea/java-tutorial-10-using-threads-with-exceptions In this tutorial, we will create an application that uses a Pipe Class, as well as 2 Threadded classes for reading and writing. So let's get started. ## PipeReadThread.java ``` class PipeReadThread extends Thread { private Pipe p; public PipeReadThread(Pipe p) { this.p = p; } public void run() { p.read(); } } ``` ## PipeWriteThread.java ``` class PipeWriteThread extends Thread { private Pipe p; public PipeWriteThread(Pipe p) { this.p = p; } public void run() { p.write(2); } } ``` In both files, we will declare a new pipe and a standart constructor. The main difference is that the ```PipeReadThread.java``` contains a method to read and the ```PipeWriteThread.java``` a method to write. ## Pipe.java - the main code ``` class Pipe { static final int MAXPIPE = 2; private Vector<String> pipevector = new Vector<String>(); public synchronized void write(int wert) { try { BufferedReader in = new BufferedReader(new InputStreamReader( System.in)); for (int i = 0; i < wert; i++) { pipevector.add(in.readLine()); } in.close(); } catch (IOException e) { } System.out.println("Schreiben ist beendet."); System.out.println(); notify(); } public synchronized void read() { while (pipevector.size() == 0) try { wait(); } catch (InterruptedException e) { } int size = pipevector.size(); for (int i = 0; i < size; i++) { System.out.println(pipevector.remove(0)); } notify(); } } ``` Firstly, the attribute ```pipevector``` is declared, which is used to store the input data. Also you can see 2 public methods ```write(int value)``` and ```read()```. The ```synchronized``` keyword is used, so that the threads can see the changes being made. Without them, it could happen, that a reading thread tries to read data, while the writing thread is not yet finished. If you were following my last tutorials, you will see a lot of code which is similar, besides the pipevector itself. So I will just continue with explaining this one. For all new people, do checkout my last tutorials to fully understand this code! So inside the ```write(int value)``` It will iterate until ```value```. So if ```value``` equals to 3, it will iterate exactly 3 times. Inside the for loop, it will read the input from the console and add it to the pipevector with the command ```pipevector.add();```. With ```notify();``` the thread states that it's now finished. Inside the ```read()``` the code ``` while (pipevector.size() == 0) try { wait(); } catch (InterruptedException e) { } ``` is called. This piece of code makes sure, that the ```read()``` function waits until the pipevector is properly being filled. Inside the for loop, the last added element is being removed and printed out to the screen. ## PipeApp.java ``` public class PipeApp { public static void main(String[] args) { Pipe p = new Pipe(); PipeReadThread p1 = new PipeReadThread(p); PipeWriteThread p2 = new PipeWriteThread(p); p1.start(); p2.start(); } } ``` ## Ouput  Stay tuned!