Решение квадратного уравнения через потоки

x1 = (b + Math.sqrt(disc)) / (2 * a);
                    System.out.println("Корень 1 = " + x1);

x2 = (b - Math.sqrt(disc)) / (2 * a);
                    System.out.println("Корень 12 = " + x2);

x1 = (-1 * b  ) / (2 * a);
                    System.out.println("Корень 1 = " + x1);

//4 потока каждый выполняет свою работу
 
public class ThreadPoool {
 
    //вычисление дискримината
    public static class Discr implements Runnable {
        private Urovnenie ur;
        Discr(Urovnenie ur) {
            this.ur = ur;
        }
 
        @Override
        public void run() {
            Thread.currentThread().setName(" Поток вычисляющий Дискриминант ");
            System.out.println(Thread.currentThread().getName() + Thread.currentThread().isAlive());
            ur.setDesc();
        }
    }
    //вычисление первого корня
    public static class Xone implements Runnable {
        private Urovnenie ur;
        Xone(Urovnenie ur) {
            this.ur = ur;
        }
 
        @Override
        public void run() {
            Thread.currentThread().setName(" вычсляющий первый корень ");
            System.out.println(Thread.currentThread().getName() + Thread.currentThread().isAlive());
            ur.xOne();
 
        }
    }
 
    //вычисление второго корня
    public static class Xtwo implements Runnable {
        private Urovnenie ur;
        Xtwo(Urovnenie ur) {
            this.ur = ur;
        }
 
        @Override
        public void run() {
            Thread.currentThread().setName(" вычсляющий второй корень ");
            System.out.println(Thread.currentThread().getName() + Thread.currentThread().isAlive());
            ur.xTwo();
 
        }
    }
    public static class Xnull implements Runnable {
        private Urovnenie ur;
        Xnull(Urovnenie ur) {
            this.ur = ur;
        }
 
        @Override
        public void run() {
            Thread.currentThread().setName(" вычсляющий корень при D = 0 ");
            System.out.println(Thread.currentThread().getName() + Thread.currentThread().isAlive());
            ur.xNull();
        }
    }
}

import java.util.concurrent.CountDownLatch;
 
/**
 * класс уровнение содержит начальные данные и методы для решения уровнения
 */
public class Urovnenie {
    private final double a;
    private final double b;
    private final double c;
    private volatile Double disc = null;
    private double x1;
    private double x2;
    CountDownLatch count = new CountDownLatch(1);
 
    Urovnenie(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
 
    public Double getDisc() {
        return disc;
    }
 
    public double getX1() {
        return x1;
    }
 
    public double getX2() {
        return x2;
    }
 
    public void setDesc() {
        disc = Math.pow(b, 2) - (4 * a * c);
        System.out.println("Дискриминант = " + disc);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count.countDown();
    }
 
    //метод вычисления первого корня
    public void xOne() {
        try {
            count.await();
            if (this.disc <= 0) {
                throw new InterruptedException();
            }
            x1 = ((-1 * b) - Math.sqrt(disc)) / (2 * a);
            System.out.println("Корень x1 = " + x1);
        } catch (InterruptedException e) {
            System.out.println("Запрос на прерывание поток " + Thread.currentThread().getName() + " вычисляющий X1 прервал работу в связи с тем, что D = " + this.disc);
        }
    }
 
    //метод вычисления второго корня
    public void xTwo() {
        try {
            count.await();
            if (this.disc <= 0) {
                throw new InterruptedException();
            }
            x2 = ((-1 * b) + Math.sqrt(disc)) / (2 * a);
            System.out.println("Корень x2 = " + x2);
        } catch (InterruptedException e) {
            System.out.println("Запрос на прерывание поток " + Thread.currentThread().getName() + " вычисляющий X2 прервал работу в связи с тем, что D = " + this.disc);
        }
    }
 
    //метод вычисления корня при D=0
    public void xNull() {
        try {
            count.await();
            if (this.disc != 0) {
                throw new InterruptedException();
            }
            x1 = (-1 * b) / (2 * a);
            System.out.println("Корень  = " + x1);
        } catch (InterruptedException e) {
            System.out.println("Запрос на прерывание поток " + Thread.currentThread().getName() + "   прервал работу в связи с тем, что D = " + this.disc);
        }
    }
}

import org.hamcrest.core.Is;
import org.junit.Assert;
import org.junit.Test;
 
 
public class UrovnenieTest {
    //старт потоков
    public void startThread(Urovnenie urovnenie) throws InterruptedException {
        Thread discThread = new Thread(new ThreadPoool.Discr(urovnenie));
        Thread xOne = new Thread(new ThreadPoool.Xone(urovnenie));
        Thread xTwo = new Thread(new ThreadPoool.Xtwo(urovnenie));
        Thread xNull = new Thread(new ThreadPoool.Xnull(urovnenie));
        discThread.start();
        xOne.start();
        xTwo.start();
        xNull.start();
        discThread.join();
        xOne.join();
        xTwo.join();
        xNull.join();
 
    }
 
    /**
     * уровнение не имеет корней
     *
     * @throws InterruptedException
     */
    @Test
    public void urovnenieTestwhendisMinnull() throws InterruptedException {
        Urovnenie urovnenie = new Urovnenie(4, 6, 10);
        this.startThread(urovnenie);
        Assert.assertThat(urovnenie.getDisc(), Is.is(-124.0));
        Assert.assertThat(urovnenie.getX1(), Is.is(0.0));
        Assert.assertThat(urovnenie.getX2(), Is.is(0.0));
        if (urovnenie.getDisc() < 0) {
            System.out.println("уровнение не имеет корней");
        }
    }
 
    /**
     * уровнение имеет один корень
     *
     * @throws InterruptedException
     */
    @Test
    public void urovnenieTestwhendisISgnull() throws InterruptedException {
        Urovnenie urovnenie = new Urovnenie(1, 6, 9);
        this.startThread(urovnenie);
        Assert.assertThat(urovnenie.getDisc(), Is.is(0.0));
        Assert.assertThat(urovnenie.getX1(), Is.is(-3.0));
    }
 
    /**
     * уровнение имеет два корня
     *
     * @throws InterruptedException
     */
    @Test
    public void urovnenieTestwhendisBignull() throws InterruptedException {
        Urovnenie urovnenie = new Urovnenie(1, 3, -4);
        this.startThread(urovnenie);
        Assert.assertThat(urovnenie.getDisc(), Is.is(25.0));
        Assert.assertThat(urovnenie.getX1(), Is.is(-4.0));
        Assert.assertThat(urovnenie.getX2(), Is.is(1.0));
 
    }
}