JavaFX未呈现数组中的早期项，无法找到问题，认为线程可能是问题所在

我编写了一个线条绘制算法，在计算每个点时可以正确运行，但是当它被渲染时，程序跳过了近20个点，无法找到问题

我试图弄乱算法，特别是for循环，它将点添加到位置列表中，在该列表中计算线，因为我在其他版本的代码中遇到了问题。我一辈子都找不到代码的问题，我对Java相当陌生，你可能会从下面混乱的代码中看出这一点。它说不要发布整个文件，但我无法指出哪里出了问题。我非常抱歉下面的代码乱七八糟，我只是在那一点上，我不知道什么是错的

package sample;

import com.sun.jdi.ArrayReference;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Group;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.util.ArrayList;

class PositionCounter {
    public int position;

    public void setPosition(int newPos){
        position = newPos;
    }
}

public class Main extends Application {

//    public void drawRectangle(int x1, int y1, int x2, int y2, Stage primStage, GraphicsContext gc){
//        drawLine(x1, y2, x2, y2 , primStage, gc);
//        drawLine(x1, y1, x2, y2, primStage, gc);
//        drawLine(x1, y1, x1 , y2, primStage, gc);
//        drawLine(x2, y1, x2 , y2, primStage, gc);
//        drawLine(x1, y1, x2, y1 , primStage, gc);
//
//    }
//

    public void fillPosition(ArrayList<Integer[]> points, GraphicsContext gc, int positionInArray ){
        gc.fillRect(points.get(positionInArray)[0], points.get(positionInArray)[1], squareWidth / 2, squareWidth / 2);
        //System.out.println("(" + points.get(positionInArray)[0] + ", " + points.get(positionInArray)[1]);
    }

    public void drawLine(int x1, int y1, int x2, int y2, Stage primStage, GraphicsContext gc){

        ArrayList<Integer[]> points = calculateLine(x1, y1, x2, y2, gc);
        PositionCounter position = new PositionCounter();

        Thread thread = new Thread(new Runnable() {

            @Override
            public void run() {

                    Runnable updater = new Runnable() {

                        @Override
                        public void run() {

                            fillPosition(points, gc, position.position);

                        }
                    };

                    int dy = Math.abs(y2 - y1);
                    int dx = Math.abs(x2 - x1);
                    int m = (dy >= dx) ? dy : dx;

                    for (int i = 0; i <= points.size(); i++) {

                        position.setPosition(i);

                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException ex) {
                        }

                        Platform.runLater(updater);

                    }


            }
        });

        thread.setDaemon(true);
        thread.start();

    }

    @Override
    public void start(Stage primaryStage) throws Exception{

        //STUFF
        Group root = new Group();
        Scene scene = new Scene(root, 400, 400);
        scene.setFill(Color.GOLD);

        Canvas canvas = new Canvas(400, 400);
        GraphicsContext gc = canvas.getGraphicsContext2D();

        root.getChildren().add(canvas);
        //////////

        gc.fillRect(0, 200, 400, 1);
        gc.fillRect(0, 100, 400, 1);
        gc.fillRect(0, 300, 400, 1);
        gc.fillRect(200, 0, 1, 400);
        gc.fillRect(100, 0, 1, 400);
        gc.fillRect(300, 0, 1, 400);


       // drawRectangle(50, 50, 350, 250, primaryStage, gc);


        //drawLine(50, 250, 350, 250 , primaryStage, gc);
        //drawLine(50, 50, 350, 250, primaryStage, gc);
        //drawLine(50, 50, 50 , 250, primaryStage, gc);
        //drawLine(350, 50, 350 , 250, primaryStage, gc);
        drawLine(50, 50, 350, 50 , primaryStage, gc);



        //////////
        primaryStage.setScene(scene);
        primaryStage.show();
        /////////
    }

    int squareWidth = 2;

    public ArrayList<Integer[]> calculateLine(int x1, int y1, int x2, int y2, GraphicsContext gc){

        ArrayList<Integer[]> points = new ArrayList<Integer[]>();

        int dy = Math.abs(y2 - y1);
        int dx = Math.abs(x2 - x1);

        int sx = (x1 < x2) ? 1 : -1;
        int sy = (y1 < y2) ? 1 : -1;

        int err = dx-dy;
        int x = x1;
        int y = y1;
        int e2 = 0;

        Integer[] pos = new Integer[2];
        pos[0] = x;
        pos[1] = y;
        points.add(pos);

        int m = (dy >= dx) ? dy  : dx ;

        for (int i = 0; i <= m; i++) {

                e2 = 2 * err;
                if (e2 > -dy) {
                    err = err - dy;
                    x = x + sx;
                    Integer[] position = new Integer[2];
                    position[0] = x;
                    position[1] = y;
                    points.add(position);
                }

                if (e2 < dx) {
                    err = err + dx;
                    y = y + sy;
                    Integer[] position = new Integer[2];
                    position[0] = x;
                    position[1] = y;
                    points.add(position);
                }

        }

        return points;
    }


    public static void main(String[] args) {
        launch(args);
    }
}

包装样品；
导入com.sun.jdi.ArrayReference；
导入javafx.application.application；
导入javafx.application.Platform；
导入javafx.scene.Group；
导入javafx.scene.canvas.canvas；
导入javafx.scene.canvas.GraphicsContext；
导入javafx.scene.paint.Color；
导入javafx.scene.scene；
导入javafx.stage.stage；
导入java.util.ArrayList；
类位置计数器{
公共职位；
公共无效设置位置（int newPos）{
位置=新位置；
}
}
公共类主扩展应用程序{
//公共空白绘图矩形（int-x1、int-y1、int-x2、int-y2、Stage-primStage、GraphicsContext-gc）{
//抽绳（x1、y2、x2、y2、初级阶段、gc）；
//抽绳（x1、y1、x2、y2、初级阶段、gc）；
//抽绳（x1，y1，x1，y2，初级阶段，gc）；
//抽绳（x2，y1，x2，y2，初级阶段，gc）；
//抽绳（x1、y1、x2、y1、初级阶段、gc）；
//
//    }
//
公共空白填充位置（ArrayList points、GraphicsContext gc、int PositionArray）{
gc.fillRect（points.get（positionInArray）[0]，points.get（positionInArray）[1]，squareWidth/2，squareWidth/2）；
//System.out.println（“（“+points.get（positionInArray）[0]+”，“+points.get（positionInArray）[1]）；
}
公共空白绘制线（int x1、int y1、int x2、int y2、Stage primStage、GraphicsContext gc）{
阵列列表点=计算线（x1，y1，x2，y2，gc）；
位置计数器位置=新位置计数器（）；
Thread Thread=新线程（new Runnable（）{
@凌驾
公开募捐{
Runnable updater=new Runnable（）{
@凌驾
公开募捐{
填充位置（点、gc、位置、位置）；
}
};
int dy=数学绝对值（y2-y1）；
int dx=数学绝对值（x2-x1）；
int m=（dy>=dx）？dy:dx；
对于（int i=0；i=dx）？dy:dx；
for（int i=0；i-dy）{
err=err-dy；
x=x+sx；
整数[]位置=新整数[2]；
位置[0]=x；
位置[1]=y；
点。添加（位置）；
}
if（e2

问题是calculate line函数返回正确的点，只是不能正确地渲染它们。

我建议您使用而不是。它可以使用

线程来完成，但是
Timeline
是为此类情况设计的

划线法：

public void绘图线（intx1、inty1、intx2、inty2、Stage primStage、GraphicsContext gc）
{
阵列列表点=计算线（x1，y1，x2，y2，gc）；
位置计数器位置=新位置计数器（）；
int dy=数学绝对值（y2-y1）；
int dx=数学绝对值（x2-x1）；
int m=（dy>=dx）？dy:dx；
AtomicInteger计数器=新的AtomicInteger（）；
时间线动画时间线=新时间线（新关键帧）（持续时间.millis（20），（动作事件t）->{
position.setPosition（counter.getAndIncrement（））；
填充位置（点、gc、位置、位置）；
}));
animationTimeline.setCycleCount（points.size（））；
animationTimeline.play（）；
}

完整代码：

import com.sun.jdi.ArrayReference；
导入javafx.application.application；
导入javafx.application.Platform；
导入javafx.scene.Group；
导入javafx.scene.canvas.canvas；
导入javafx.scene.canvas.GraphicsContext；
导入javafx.scene.paint.Color；
导入javafx.scene.scene；
导入javafx.stage.stage；
导入java.util.ArrayList；
导入java.util.concurrent.AtomicInteger；
导入javafx.animation.KeyFrame；
导入javafx.animation.Timeline；
导入javafx.event.ActionEvent；
导入javafx.event.EventHandler；
导入javafx.util.Duration；
类位置计数器
{
公共职位；
公共无效设置位置（int newPos）
{
位置=新位置；
}
}
公共类JavaFXTestingGround扩展了应用程序
{
//公共空白绘图矩形（int-x1、int-y1、int-x2、int-y2、Stage-primStage、GraphicsContext-gc）{
//抽绳（x1、y2、x2、y2、初级阶段、gc）；
//抽绳（x1、y1、x2、y2、初级阶段、gc）；
//抽绳（x1，y1，x1，y2，初级阶段，gc）；
//抽绳（x2，y1，x2，y2，初级阶段，gc）；
//抽绳（x1、y1、x2、y1、初级阶段、gc）；
//
//    }
//
公共空白填充位置（ArrayList points、GraphicsContext gc、int PositionArray）
{
gc.fillRect（points.get（positionInArray）[0]，points.get（positionInArray）[1]，squareWidth/2，squareWidth/2）；
//System.out.println（“（“+points.get（positionInArray）[0]+”，“+points.get（positionInArray）[1]）；
}
公共空隙抽绳(
public void drawLine(int x1, int y1, int x2, int y2, Stage primStage, GraphicsContext gc)
{

    ArrayList<Integer[]> points = calculateLine(x1, y1, x2, y2, gc);
    PositionCounter position = new PositionCounter();

    int dy = Math.abs(y2 - y1);
    int dx = Math.abs(x2 - x1);
    int m = (dy >= dx) ? dy : dx;

    AtomicInteger counter = new AtomicInteger();
    Timeline animationTimeline = new Timeline(new KeyFrame(Duration.millis(20), (ActionEvent t) -> {
        position.setPosition(counter.getAndIncrement());
        fillPosition(points, gc, position.position);
    }));
    animationTimeline.setCycleCount(points.size());
    animationTimeline.play();

}

import com.sun.jdi.ArrayReference;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Group;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.util.Duration;

class PositionCounter
{

    public int position;

    public void setPosition(int newPos)
    {
        position = newPos;
    }
}

public class JavaFXTestingGround extends Application
{

//    public void drawRectangle(int x1, int y1, int x2, int y2, Stage primStage, GraphicsContext gc){
//        drawLine(x1, y2, x2, y2 , primStage, gc);
//        drawLine(x1, y1, x2, y2, primStage, gc);
//        drawLine(x1, y1, x1 , y2, primStage, gc);
//        drawLine(x2, y1, x2 , y2, primStage, gc);
//        drawLine(x1, y1, x2, y1 , primStage, gc);
//
//    }
//
    public void fillPosition(ArrayList<Integer[]> points, GraphicsContext gc, int positionInArray)
    {
        gc.fillRect(points.get(positionInArray)[0], points.get(positionInArray)[1], squareWidth / 2, squareWidth / 2);
        //System.out.println("(" + points.get(positionInArray)[0] + ", " + points.get(positionInArray)[1]);
    }

    public void drawLine(int x1, int y1, int x2, int y2, Stage primStage, GraphicsContext gc)
    {

        ArrayList<Integer[]> points = calculateLine(x1, y1, x2, y2, gc);
        PositionCounter position = new PositionCounter();

        int dy = Math.abs(y2 - y1);
        int dx = Math.abs(x2 - x1);
        int m = (dy >= dx) ? dy : dx;

        AtomicInteger counter = new AtomicInteger();
        Timeline animationTimeline = new Timeline(new KeyFrame(Duration.millis(20), (ActionEvent t) -> {
            position.setPosition(counter.getAndIncrement());
            fillPosition(points, gc, position.position);
        }));
        animationTimeline.setCycleCount(points.size());
        animationTimeline.play();

    }

    @Override
    public void start(Stage primaryStage) throws Exception
    {

        //STUFF
        Group root = new Group();
        Scene scene = new Scene(root, 400, 400);
        scene.setFill(Color.GOLD);

        Canvas canvas = new Canvas(400, 400);
        GraphicsContext gc = canvas.getGraphicsContext2D();

        root.getChildren().add(canvas);
        //////////

        gc.fillRect(0, 200, 400, 1);
        gc.fillRect(0, 100, 400, 1);
        gc.fillRect(0, 300, 400, 1);
        gc.fillRect(200, 0, 1, 400);
        gc.fillRect(100, 0, 1, 400);
        gc.fillRect(300, 0, 1, 400);

        // drawRectangle(50, 50, 350, 250, primaryStage, gc);
        //drawLine(50, 250, 350, 250 , primaryStage, gc);
        //drawLine(50, 50, 350, 250, primaryStage, gc);
        //drawLine(50, 50, 50 , 250, primaryStage, gc);
        //drawLine(350, 50, 350 , 250, primaryStage, gc);
        drawLine(50, 50, 350, 50, primaryStage, gc);

        //////////
        primaryStage.setScene(scene);
        primaryStage.show();
        /////////
    }

    int squareWidth = 2;

    public ArrayList<Integer[]> calculateLine(int x1, int y1, int x2, int y2, GraphicsContext gc)
    {

        ArrayList<Integer[]> points = new ArrayList<Integer[]>();

        int dy = Math.abs(y2 - y1);
        int dx = Math.abs(x2 - x1);

        int sx = (x1 < x2) ? 1 : -1;
        int sy = (y1 < y2) ? 1 : -1;

        int err = dx - dy;
        int x = x1;
        int y = y1;
        int e2 = 0;

        Integer[] pos = new Integer[2];
        pos[0] = x;
        pos[1] = y;
        points.add(pos);

        int m = (dy >= dx) ? dy : dx;

        for (int i = 0; i <= m; i++) {

            e2 = 2 * err;
            if (e2 > -dy) {
                err = err - dy;
                x = x + sx;
                Integer[] position = new Integer[2];
                position[0] = x;
                position[1] = y;
                points.add(position);
            }

            if (e2 < dx) {
                err = err + dx;
                y = y + sy;
                Integer[] position = new Integer[2];
                position[0] = x;
                position[1] = y;
                points.add(position);
            }

        }

        return points;
    }

    public static void main(String[] args)
    {
        launch(args);
    }
}