Threads managen / Schleife fortsetzen, wenn Thread beendet

public class MainFrameController implements Initializable {

    @FXML
    private TableColumn<Track, String> colDwTitle;
    @FXML
    private TableColumn<Track, Double> colDwProgress;
    @FXML
    private TableView<Track> dwtable;

    ObservableList<Track> tracks = FXCollections.observableArrayList();

SQLite sql;
public static YouTube ydown;

@Override
    public void initialize(URL url, ResourceBundle rb) {
        
        sql = new SQLite();
        tracks = sql.getAllSongs();


        
        dwtable.setItems(tracks);
        colDwTitle.setCellValueFactory((p) -> new SimpleStringProperty(p.getValue().getArtist() + " - " + p.getValue().getName()));

        colDwProgress.setCellValueFactory(new PropertyValueFactory<>(
                "progress"));
        colDwProgress.setCellFactory(ProgressBarTableCell.<Track>forTableColumn());
        
	}

@FXML
    private void btnDownload(ActionEvent event) 
    {
        
        //ExecutorService executor = Executors.newFixedThreadPool(1, new ThreadFactory() {
        
        ThreadPoolExecutor executor;
        executor = new ThreadPoolExecutor(3, 3, 2, TimeUnit.MINUTES, new ArrayBlockingQueue<Runnable>(3));
        
        
        //ExecutorService es = Executors.newCachedThreadPool();
        
        ydown = new YouTube();
        
        int zaehler = 0;
        
        
        Task progress = new Task<Void>() {
            @Override
            public Void call() {

                this.updateProgress(dwtable.getItems().size(), 1);
                
                while (ydown.Percent < 100) {
                    if (isCancelled()) {
                        break;
                    }
                    setPercent(null, ydown.Percent);
                    updateProgress(ydown.Percent, 100);
                                        
                    System.out.println("Prozent: " + ydown.Percent);
                    
                }
                updateProgress(100, 100);
                ydown.Percent = 0;
                
                
                
                return null;
            }
        };

        Task download = new Task<Void>() {
            @Override
            public Void call() {

                
                ydown.download(dwtable.getItems().get(zaehler).getYouTube());
                zaehler++;
                finish = true;
                return null;
            }
        };
        
        
        
        for(Track tr : dwtable.getItems()) 
        {
                        
            try {
                executor.execute((Runnable) tr);
                testProg.progressProperty().bind(progress.progressProperty());

                executor.execute(download);
                executor.execute(progress);
                finish = false;
                               
                
            } catch (Exception ex) {
                Logger.getLogger(MainFrameController.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        
        executor.shutdown();
        while(!executor.isTerminated())
        {
            
        }
        System.out.println("Finished All Threads");

    }
	
public void setPercent(Track tr, double per)
    {
        Track.percent = per;
        
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package chartsjavafx.services;

import chartsjavafx.MainFrameController;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.concurrent.Task;
import javafx.scene.control.ProgressIndicator;

/**
 *
 * @author Tobias
 */
public class Track extends Task<Void> {

    String name, art, rem, lab, gen, dat, ytb;
    
    //IntegerProperty downloadProgress;
    private DoubleProperty downloadProgress;
    public static double percent;

    public static final int NUM_ITERATIONS = 100;
    
    MainFrameController mfc;
    
    public Track(String trackname, String artist, String remix, String label, String genretr, String date, String youtube) {
        name = trackname;
        art = artist;
        rem = remix;
        lab = label;
        gen = genretr;
        dat = date;
        ytb = youtube;
        
        downloadProgress = new SimpleDoubleProperty(0);
    }

    public ArrayList<String> getTrackInfo() {
        ArrayList<String> info = new ArrayList<String>();

        info.add(name);
        info.add(art);
        info.add(rem);
        info.add(lab);
        info.add(gen);
        info.add(dat);
        info.add(ytb);

        return info;
    }

    public String getTrack() {
        String track = name + " - " + art + " - " + rem + " - " + lab + " - " + gen + " - " + dat;

        return track;
    }

    public String getName() {
        return name;
    }

    public String getArtist() {
        return art;
    }

    public String getRemixer() {
        return rem;
    }

    public String getLabel() {
        return lab;
    }

    public String getGenre() {
        return gen;
    }

    public String getReleaseDate() {
        return dat;
    }

    public String getYouTube() {
        return ytb;
    }

    public DoubleProperty getDownloadProgress() {
        return downloadProgress;
    }
    
    public void setProgressBar(double percent) 
    {
        this.downloadProgress = new SimpleDoubleProperty(percent);
    }
    
    @Override
    protected Void call() throws Exception
    {
    
        mfc = new MainFrameController();
        this.updateProgress(ProgressIndicator.INDETERMINATE_PROGRESS, 100);
        
        while(percent < 100)
        {
            updateProgress(percent, 100);
        }
        
        updateProgress(100, 100);
        percent = 0;
        
        return null;
    }

}

import chartsjavafx.MainFrameController;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLEncoder;
import javax.net.ssl.HttpsURLConnection;

import com.google.gson.*;
import com.google.gson.stream.JsonReader;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.json.*;

public class YouTube {

    public static int filesize;
    public static float totalDataRead = 0;
    public static float Percent = 0;

    public static void download(String ytburl)
    {
        
        Percent = 0;
        
        
        //ytburl = "https://www.youtube.com/watch?v=h5-mjniYSIY";
        
        try {
            
            /*
            JSON holen
            */
            String urlparameters = "api=advanced&format=JSON&video=" + ytburl;
            
            String url = "http://youtubeinmp3.com/fetch/?" + urlparameters;
            
            URL obj = new URL(url);
            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
            
            con.setRequestMethod("GET");
            
            con.setRequestProperty("User-Agent", USER_AGENT);
            
            
            
            
            responseCode = con.getResponseCode();
            System.out.println("\nSending 'GET' request to URL : " + url);
            System.out.println("Response Code : " + responseCode);
            
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuffer response = new StringBuffer();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            String json = String.valueOf(response);
            String dwnlink = "";
            String filename = "";
            
            
            /*
            JSON auslesen, DownloadLink holen
            */

            JSONObject obj2 = new JSONObject(json);
            
            filename = obj2.getString("title") + ".mp3";
            dwnlink = obj2.getString("link");
                
            URL url2 = new URL(dwnlink);
            HttpURLConnection connection = (HttpURLConnection) url2.openConnection();
            int filesize = connection.getContentLength();

            float totalDataRead = 0;
            java.io.BufferedInputStream in2 = new java.io.BufferedInputStream(connection.getInputStream());
            java.io.FileOutputStream fos = new java.io.FileOutputStream(filename);
            java.io.BufferedOutputStream bout = new BufferedOutputStream(fos, 1024);
            byte[] data = new byte[1024];
            int i = 0;
            while ((i = in2.read(data, 0, 1024)) >= 0) 
            {
                totalDataRead = totalDataRead + i;
                bout.write(data, 0, i);
                Percent = (totalDataRead * 100) / filesize;
            }
            bout.close();
            in.close();
            
            org.apache.commons.io.FileUtils.copyURLToFile(new URL(dwnlink), new File(DATAPATH + filename));
            
            System.out.println("Download done!");
                
                
            
            //print result
        } catch (MalformedURLException ex) {
            Logger.getLogger(YouTube.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ProtocolException ex) {
            Logger.getLogger(YouTube.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(YouTube.class.getName()).log(Level.SEVERE, null, ex);
        } catch (JSONException ex) {
            Logger.getLogger(YouTube.class.getName()).log(Level.SEVERE, null, ex);
        } /*catch (JSONException ex) {
            Logger.getLogger(YouTube.class.getName()).log(Level.SEVERE, null, ex);
        }*/
        
    }