stackoveflow java jcp threads paprastesnis

package ilginist_l3g;

import org.jcsp.lang.Alternative;
import org.jcsp.lang.AltingChannelInput;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.Channel;
import org.jcsp.lang.ChannelOutput;
import org.jcsp.lang.Guard;
import org.jcsp.lang.One2OneChannel;
import org.jcsp.lang.Parallel;
import org.jcsp.lang.SharedChannelOutput;
import org.jcsp.util.InfiniteBuffer;


// Programoje naudojau One2One kanala Rasytojas -> Valdytojas, nes naudojant viena kanala Any2One
// programa per greit pasibaigdavo ir visus veiksmus atlikdavo viena gija
// Naudojant alternative metoda fairSeletect gijos priverciamos veikti pasikeisdamos, todel visas darbas nelieka vienai gijai
public class IlginisT_L3g {

    private static Parallel parallel = new Parallel();

    public void execute(){
        One2OneChannel[] writerToManager = Channel.one2oneArray(3, new InfiniteBuffer());
        One2OneChannel[] managerToReader = Channel.one2oneArray(2, new InfiniteBuffer());

        Any2OneChannel workFinished = Channel.any2one(new InfiniteBuffer());

        parallel.addProcess(new ControllerThread(writerToManager, managerToReader, workFinished.out()));

        for (int i = 0; i < 3; i++){
            parallel.addProcess(new WriterThread(i+1, writerToManager[i].out(), workFinished.in()));
        }

        parallel.addProcess(new ReaderThread(4, managerToReader[0].in()));
        parallel.addProcess(new ReaderThread(5, managerToReader[1].in()));

        parallel.run();
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        new IlginisT_L3g().execute();
    }


class ControllerThread implements CSProcess{

    private static final String threadName = "procesas_VA";

    int n, m;
    int changedCount;

    private One2OneChannel[] fromWriters;
    private One2OneChannel[] toReaders;

    private SharedChannelOutput workFinishedOutput;

    private Guard[] guards;
    private Alternative alt;

    public ControllerThread(One2OneChannel[] fromWriters, One2OneChannel[] toReaders, SharedChannelOutput workFinished){

        this.fromWriters = fromWriters;
        this.toReaders = toReaders;
        workFinishedOutput = workFinished;

        n = 0;
        m = 100;

        guards = new Guard[3];

        for (int i = 0; i < 3; i++){
            guards[i] = fromWriters[i].in();
        }

        alt = new Alternative(guards);

        changedCount = 0;
    }

    public void doTask(){
        while (!workFinished()){
            int guardInd = alt.fairSelect();

            if (fromWriters[guardInd].in().pending()){
                Object ob = fromWriters[guardInd].in().read();
                int data = (Integer) ob;
                n += data;
                m -= data;

                // Patikrinimui kuris procesas atsiunte duomenis
                System.out.println("GAUTA: " + data + "      N = " + n + "      M = " + m);

                changedCount++;
                if (changedCount >= 2){
                    toReaders[0].out().write(new Number(n, m));

                    toReaders[1].out().write(new Number(n, m));
                    changedCount = 0;
                }

            }
        }

    }

    public void sendDataToReaders(){

    }

    private boolean workFinished(){
        if (Math.abs(n-m) <=5)
            return true;
        return false;
    }

     public void notifyWriters(){
        for (int i = 0; i < 3; i++)
            workFinishedOutput.write(1);
    }

     public void notifyReaders(){
        toReaders[0].out().write(new Number(-99, -99));
        toReaders[1].out().write(new Number(-99, -99));
     }


    @Override
    public void run() {
        System.out.format("%-15s has started\n", threadName);

        doTask();
        notifyWriters();
        notifyReaders();

        System.out.format("%-15s has finished\n", threadName);
    }

}

class WriterThread implements CSProcess{

    private int threadInd;
    private String threadName = "Rasytojas_";

    private ChannelOutput output;
    private AltingChannelInput input;

    public WriterThread(int ind, ChannelOutput out, AltingChannelInput in){
        threadInd = ind;
        threadName += ind;

        output = out;
        input = in;
    }


    public void sendDataToManager(){
        boolean pending = false;

        while(!pending){                // Kai kanale Valdytojas -> Rasytojas atsiranda duomenys, reiskia darbas baigtas
            output.write(threadInd);

            if (input.pending()){
                    pending = true;
                    break;
            }
        }
    }

    @Override
    public void run() {
        System.out.format("%-15s has started\n", threadName);

        sendDataToManager();

        System.out.format("%-15s has finished\n", threadName);
    }

}

class Number{
    private int n, m;

    public Number(int first, int second){
        n = first;
        m = second;
    }

    public int getN(){
        return n;
    }

    public int getM(){
        return m;
    }

}

class ReaderThread implements CSProcess{

    private int threadInd;
    private String threadName = "Skaitytojas_";

    private AltingChannelInput input;

    public ReaderThread(int ind, AltingChannelInput in){

        threadInd = ind;
        threadName += ind;

        input = in;
    }


    public void getDataFromManager(){
        boolean workFinished = false;

        while (!workFinished){      // kol Valdytojas -> Skaitytojas kanalu negautas skaicius -99, darbas tebevyksta
            if (input.pending()){
                Object ob = input.read();
                Number data = (Number) ob;

                if (data.getN() == -99){
                    workFinished = true;
                }else{
                    System.out.format("%-15s N = %5d     M = %5d \n", threadName, data.getN(), data.getM());
                }
            }
        }

    }

    @Override
    public void run() {
        System.out.format("%-15s has started\n", threadName);

        getDataFromManager();

        System.out.format("%-15s has finished\n", threadName);
    }

}



}