Остановка потоков

//поток слежения за временем
class Time implements Runnable {
    private long ms;
    private String name;
 
    Time(String name, long ms) {
        this.name = name;
        this.ms = ms;
    }
 
    @Override
    public void run() {
        long ms = System.currentTimeMillis();
        try {
            //тут цикл ожидания времени, и если
            //второй поток закончил работу раньше, чем время ожидания
            //то просто закончить поток
            //если время ожидания исчерпано, закончить этот поток и другой
            System.out.printf("The thread [%s] is end work!%s", this.name, System.lineSeparator());
        } catch (InterruptedException e) {
            System.out.printf("The thread [%s] is stop!%s", this.name, System.lineSeparator());
        }
    }
}

class CountChar implements Runnable {
    private String name;
    private String offer;
 
    CountChar(String name, String offer) {
        this.name = name;
        this.offer = offer;
    }
 
    @Override
    public void run() {
        if (this.offer != null) {
            int countSymbols = 0;
            try {
                //тут мы считаем допустим кол-во символов в тексте
                System.out.printf("Text have %d symbols.%s", countSymbols, System.lineSeparator());
                System.out.printf("The thread [%s] is end work!%s", this.name, System.lineSeparator());
            } catch (InterruptedException e) {
                System.out.printf("The thread [%s] is stop!%s", this.name, System.lineSeparator());
            }
        }
    }
}

public void start() {
        Thread time = new Thread(new Time("ThreadTime", ms));
        Thread countChar = new Thread(new CountChar("ThreadCountChar", this.offer));
        time.start();
        countChar.start();
        while (!time.isInterrupted() || !countChar.isInterrupted()) {
            if (time.isInterrupted() && !countChar.isInterrupted()) {
                stopThread(countChar);
            }
            if (countChar.isInterrupted() && !time.isInterrupted()) {
                stopThread(time);
            }
        }
    }
 
    private void stopThread(Thread thread) {
        if (thread != null) {
            if (!thread.isInterrupted()) {
                thread.interrupt();
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

 Thread.currentThread().isInterrupted();

time.join();
countChar.join();

for (int i = 0; i < 10; i++) {
   count++;
}

for (int i = 0; i < 10; i++) {
   Thread.sleep(ms);
   count++;
}

import java.math.BigInteger;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
 
public final class CountTimed {
 
    public static void main(String[] args) throws Exception {
        final ExecutorService executorService = Executors.newFixedThreadPool(2);
        final AtomicBoolean aborted = new AtomicBoolean(false);
        try {
            final Future<BigInteger> count = executorService.submit(() -> countCharsWithLimit(aborted::get));
            final Future<Boolean> done = executorService.submit(() ->
                await(count, 1, TimeUnit.SECONDS,
                        (result) -> System.out.println("count = " + result),
                        () -> {
                            aborted.set(true);
                            System.out.println("timeout");
                        }
            ));
            System.out.println("waiting for result...");
            //aborted.set(true); // uncomment to emulate successful (before timeout) end of countCharsWithLimit
            done.get();
        } finally {
            executorService.shutdown();
        }
    }
 
    private static <T> boolean await(
            Future<T> future,
            long timeout,
            TimeUnit unit,
            Consumer<T> resultConsumer,
            Runnable timeoutAction
    ) throws ExecutionException, InterruptedException {
        try {
            final T result = future.get(timeout, unit);
            resultConsumer.accept(result);
            return true;
        } catch (TimeoutException e) {
            future.cancel(true);
            timeoutAction.run();
            return false;
        }
    }
 
    private static BigInteger countCharsWithLimit(BooleanSupplier aborted) {
        BigInteger count = BigInteger.ZERO;
        while (!aborted.getAsBoolean()) {
            count = count.add(BigInteger.ONE);
        }
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        CountChar countChar = new CountChar("String"); // я не знаю какие тексты ты там передаешь, просто пример
        Thread countThread = new Thread(countChar);
        Thread timeThread= new Thread(new Time(countThread,countChar,600)); //600 миллисекунд ждет поток времени
        timeThread.start();
        countThread.start();
        try {
            timeThread.join(); //джойнимся чтобы дождаться завершения потока времени
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

public final class CountChar implements Runnable {
    private volatile boolean flag =true; //флаг что еще можно работать и никто не требует остановки
    private final String textToWork; //это твой текст который ты передаешь, что с ним дальше делать решай
 
    public void setFlag(boolean flag) { /метод для внешних объектов для требования остановки
        this.flag = flag;
    }
 
    public CountChar(String textToWork) {
        this.textToWork = textToWork;
    }
 
    @Override
    public void run() {
        int count=0; //не надо так делать, я тут просто имитирую некоторую работу
        while (flag) { //пока не просят остановки            
            try {
                Thread.sleep(500); //вместо этого что то делаем с текстом
                System.out.println(".");
                count++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           if(count>=4){ //тут мы все сделали и просто завершаемся
                break;
           }
        }
    }
}

public final class Time implements  Runnable {
    private final Thread countCheckThread;
    private final CountChar countChar;
    private final long timeInMilliseconds; //время ожидания в миллисекундах
 
    public Time(Thread countCheckThread, CountChar countChar, long timeInMilliseconds) {
        this.countCheckThread = countCheckThread;
        this.countChar = countChar;
        this.timeInMilliseconds = timeInMilliseconds;
    }
 
    @Override
    public void run() {
        long startTime =System.currentTimeMillis(); //начало отсчета
        while (countCheckThread.isAlive()){ //пока работяга еще жив и пашет
            long nowTime = System.currentTimeMillis();
            if (nowTime-startTime>=timeInMilliseconds) { //время истекло
                countChar.setFlag(false); //просим работягу остановиться
                System.out.println("Time is over! Stopping thread ...");
                try {
                    countCheckThread.join(); //ждем чтобы работяга остановился (там быстро)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Time elapsed: " + (System.currentTimeMillis()-startTime)); //время выводим в любом случае
    }
}