Чтение теста из файлов в Java. java коллекции, потоки. создать приложение, в котором будет два отдельных потока

import java.io.*;
import java.util.*;
import java.util.List;
 
public class CountryParse {
    private static final int AMOUNT_THREAD = 2;
    private final String[] paths;
    private final List<Thread> poll;
 
    private final Queue<Thread> threadQueue;
    private final Queue<String> queue;
 
    private Set<CountryInfo> tree;
 
    CountryParse(String pathCountry, String pathCapital) {
        checkArguments(pathCountry, pathCapital);
        this.paths = new String[AMOUNT_THREAD];
        this.paths[0] = pathCountry;
        this.paths[1] = pathCapital;
        this.poll = new ArrayList<>();
        this.queue = new PriorityQueue<>();
        this.threadQueue = new PriorityQueue<>();
        this.tree = new TreeSet<>();
    }
 
    private void createPool() {
        for (String path : this.paths) {
            this.poll.add(new Thread(new Reader(this, path)));
        }
    }
 
    private void startPool() {
        for (Thread thread : this.poll) {
            thread.start();
        }
    }
 
    void parse() {
        createPool();
        startPool();
        while (isActive()) {
            synchronized (this.queue) {
                if (this.queue.size() == 2) {
                    String country = this.queue.poll();
                    String capital = this.queue.poll();
                    this.tree.add(new CountryInfo(country, capital));
                    this.queue.notifyAll();
                }
            }
        }
    }
 
    public CountryInfo[] toArray() {
        return this.tree.toArray(new CountryInfo[0]);
    }
 
    public CountryInfo[] toArray(Comparator<CountryInfo> c) {
        return this.tree.stream().sorted(c).toArray(CountryInfo[]::new);
    }
 
    private boolean isActive() {
        boolean result = false;
        for (Thread thread : this.poll) {
            if (thread.isAlive()) {
                result = true;
                break;
            }
        }
        return result;
    }
 
    private void checkArguments(String first, String second) {
        if (first == null || second == null) {
            throw new IllegalArgumentException("Arguments not may be null.");
        }
    }
 
    private void addByQueue(String value) {
        try {
            synchronized (this.threadQueue) {
                if (!this.threadQueue.isEmpty()) {
                    while (this.threadQueue.peek() == Thread.currentThread()) {
                        this.threadQueue.wait();
                    }
                    this.threadQueue.poll();
                }
                this.threadQueue.offer(Thread.currentThread());
                addValue(value);
                this.threadQueue.notify();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
    }
 
    private void addValue(String value) throws InterruptedException {
        synchronized (this.queue) {
            while (this.queue.size() >= AMOUNT_THREAD) {
                this.queue.wait();
            }
            this.queue.offer(value);
        }
    }
 
    private class Reader implements Runnable {
        private final CountryParse parse;
        private final String path;
 
        Reader(CountryParse parse, String path) {
            this.parse = parse;
            this.path = path;
        }
 
        @Override
        public void run() {
            try (Scanner read = new Scanner(new File(this.path))) {
                while (read.hasNextLine()) {
                    this.parse.addByQueue(read.nextLine());
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}
 
class CountryInfo implements Comparable<CountryInfo> {
    private final String country;
    private final String capital;
 
    String getCapital() {
        return capital;
    }
 
    CountryInfo(String country, String capital) {
        this.country = country;
        this.capital = capital;
    }
 
    @Override
    public String toString() {
        return String.format("%s - %s", this.country.toUpperCase(), this.capital);
    }
 
    @Override
    public int compareTo(CountryInfo o) {
        return o != null ? this.country.compareTo(o.country) : 0;
    }
}
 
class CountryParseTest {
    private static final String COUNTRY = "countries.txt";
    private static final String CAPITAL = "capitals.txt";
 
    public static void main(String[] args) {
        CountryParse countryParse = new CountryParse(COUNTRY, CAPITAL);
        countryParse.parse();
 
        System.out.println("Default sort by country:");
        for (CountryInfo countryInfo : countryParse.toArray()) {
            System.out.println("   " + countryInfo);
        }
 
        System.out.println("\nSort by capital:");
        for (CountryInfo countryInfo : countryParse.toArray(Comparator.comparing(CountryInfo::getCapital))) {
            System.out.println("   " + countryInfo);
        }
    }
}

Angola
Sudan
Kazakhstan
Paraguay
Portugal
Syria
Bahamas
Greece
Latvia
Morocco
Iran
Panama
Guatemala
Iraq
Laos
Nepal
Vatican
Seychelles
Ukraine
Africa
Tanzania
Zambia
Britain
Ghana
Bahrain
Congo
Canada
Maldives
Turkey
Belgium
Namibia
Finland
Georgia
Jamaica
Turkmenistan
Peru
Germany
Guinea
Somalia
Madagascar
Thailand
Vietnam
Sweden
Liechtenstein
Poland
Jordan
Nigeria
Bulgaria
Tunisia
Croatia
Uruguay
Kenya
Spain
Lebanon
Azerbaijan
Cuba
Venezuela
Liberia
Israel
Australia
Tajikistan
Estonia
Cameroon
Cyprus
Timor
Oman
Iceland
Armenia
Gabon
Austria
Mozambique
Nevis
Arabia
Monaco
Luxembourg
Brazil
Algeria
Slovenia
Ecuador
Hungary
Japan
Belarus
Verde
Albania
Senegal
Italy
Honduras
Macedonia
Nauru
Afghanistan
Burundi
Singapore
Egypt
Bolivia
Malta
Russia
Netherlands
Pakistan
Gambia
China
Ireland
Qatar
America
Slovakia
Serbia
France
Kyrgyzstan
Korea
Romania
Philippines
Uzbekistan
Nicaragua
Barbados
Norway
Denmark
Zimbabwe
Uganda
Mexico
Grenadines
Indonesia

Luanda
Khartoum
Astana
Asuncion
Lisbon
Damascus
Nassau
Athens
Riga
Rabat
Tehran
Panama
Guatemala
Baghdad
Vientiane
Katmandu
Vatican
Victoria
Kiev
Pretoria
Dodoma
Lusaka
London
Accra
Manama
Kinshasa
Ottawa
Male
Ankara
Brussels
Windhoek
Helsinki
Tbilisi
Kingston
Ashgabat
Lima
Berlin
Malabo
Mogadishu
Antananarivo
Bangkok
Hanoi
Stockholm
Vaduz
Warsaw
Amman
Abuja
Sofia
Tunis
Zagreb
Montevideo
Nairobi
Madrid
Beirut
Baku
Havana
Caracas
Monrovia
Jerusalem
Canberra
Dushanbe
Tallinn
Yaounde
Nicosia
Dili
Muscat
Reykjavik
Yerevan
Libreville
Vienna
Maputo
Basseterre
Riyadh
Monaco
Luxembourg
Brasilia
Algiers
Ljubljana
Quito
Budapest
Tokyo
Minsk
Praia
Tirana
Dakar
Rome
Tegucigalpa
Skopje
Yaren
Kabul
Bujumbura
Singapore
Cairo
Sucre
Valletta
Moscow
Amsterdam
Islamabad
Banjul
Peking
Dublin
Doha
Washington
Bratislava
Belgrade
Paris
Bishkek
Pyongyang
Bucharest
Manila
Tashkent
Managua
Bridgetown
Oslo
Copenhagen
Harare
Kampala
City
Kingstown
Jakarta