Java Swing : Improving cursor response using Threads

Question

我需要加快悬停在一堆矩形上的光标响应速度。随着矩形数量(或复杂性)的增加，迭代矩形的直接线性算法开始恶化。

这个超链接展示了一个线性搜索模型(记得添加break关键字!!!)linear approach

为了清楚地表明我的意思，下面是一个 JPanel 的代码，它有两组矩形。第一组是 y 轴上的矩形列表，第二组是 x 轴上的矩形列表。

请记住，我的解决方案是我能想到的最好的解决方案，即使用两个线程来并发迭代；每个列表一个线程，一个用于 x 轴，另一个用于 y 轴。我放弃的次优解决方案(代码未显示)是循环内有一个循环。一个循环专用于 x 轴矩形，另一个循环专用于 y 轴矩形。这一点，我认为通过 contains() 方法搜索 y 轴矩形(假设内部循环专用于 y 轴矩形)通过首先循环所有 x 轴矩形而施加了过度的开销。

为了改进线性模型，我想到了这种线程方法来同时参与工作线程。

顺便说一句，我是一个java新手，尤其是多线程方面。

问题:一个线程似乎会干扰另一个线程的性能。下面的算法是由两个扩展 Thread 的包装类实现的，它们都有迭代矩形的方法。如果另一个线程被注释掉，它们都可以很好地工作，即每个单独和单独都可以很好地工作，但是当两者同时启动时，其中一个会导致性能下降。

如果我 join() 一个线程，这不是会恢复到线性模型，随着矩形复杂性的增加，这种搜索算法是很糟糕的吗？

(复杂性不仅意味着水平和垂直，还意味着对角线等矩形)？

public class FlyingSaucer extends JPanel {
    Rectangle2D rec;
    Rectangle2D rec1; 
    List<Rectangle2D> recList;
    List<Rectangle2D> recList2;

    Rectangle2D.Double mouseBoxx;  
    int f = 10;
    int g = 0;
    int s = 10;
    int y = 5;
    int z = 500;

    public FlyingSaucer(){

        //FlyingSaucer needs to quickly identify specific points over given areas
        //enclosed in rectangles.They use a 'divide and conquer' approach where 
        //different types of rectangles are first identified and a worker thread
        //assigned to each category

        mouseBoxx = new Rectangle.Double();
        recList = new ArrayList<>();
        recList2 = new ArrayList<>();

        for(int i = 0; i < 15; i++){
            rec = new Rectangle2D.Double(2+f,10+g,5,1000);       
            f +=50;
            recList.add(rec);                
        }
        f = 10;

        for(int i = 0; i < 20; i++){
            rec1 = new Rectangle2D.Double(2+y,10+s,1000,5);       
            s +=35;
            recList2.add(rec1);                
        }
        s = 10;
    }


    public static void main(String[] args) {
        JFrame frame = new JFrame();
        FlyingSaucer fs = new FlyingSaucer();
        Laser laser = new Laser(fs);
        fs.addMouseMotionListener(laser);
        fs.addMouseListener(laser);
        frame.getContentPane().add(fs);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(700,700);
        frame.setVisible(true);     
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g); 
        ((Graphics2D)g).setColor(Color.RED);
        int a = 10;
        int b = 10;

        for(int i = 0;i < recList.size();i++){               
           ((Graphics2D)g).draw(recList.get(i));
        }

        for(int i = 0;i < recList2.size();i++){               
           ((Graphics2D)g).draw(recList2.get(i));
        }
    }
}

class Laser implements MouseListener,MouseMotionListener{
    Rectangle2D.Double mouseBox;
    Rectangle2D.Double recx;
    Rectangle2D.Double recy;
    FlyingSaucer fs;
    public Laser(FlyingSaucer fs){
        this.fs = fs;
    }

    @Override public void mouseClicked (MouseEvent e) { }
    @Override public void mousePressed (MouseEvent e) { }
    @Override public void mouseReleased(MouseEvent e) { }
    @Override public void mouseEntered (MouseEvent e) { }
    @Override public void mouseExited  (MouseEvent e) { }
    @Override public void mouseDragged (MouseEvent e) { }

    @Override
    public void mouseMoved(MouseEvent e) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                double x = e.getX();
                double y = e.getY();

                mouseBox = fs.mouseBoxx;
                mouseBox = new Rectangle2D.Double(x-5,y-5,10,10);

                Graphics g = fs.getGraphics();
                ((Graphics2D)g).setColor(Color.BLACK);
                ((Graphics2D)g).draw(mouseBox);

                //thread one for horizontal rectangles
                HorizontalBuffer hb = new HorizontalBuffer(fs,e);
                hb.start();

                //thread two for vertical rectangles
                VerticalBuffer vb = new VerticalBuffer(fs,e);
                vb.start();

                fs.repaint();
                g.dispose();
        }});
    }

    class HorizontalBuffer extends Thread{
        FlyingSaucer fs;
        MouseEvent e;
        List<Rectangle2D> recX;

        public HorizontalBuffer(FlyingSaucer fs,MouseEvent e){
            this.fs = fs;
            this.e = e;
        }

        public void run() {
            recX = fs.recList;
            Iterator <Rectangle2D> recs = recX.iterator();  
            int v = 1;
            while(recs.hasNext()){
                recx = (Rectangle2D.Double) recs.next();
                if(recx.contains(e.getPoint())){
                    System.out.println("X rectangle detected.."+v);
                     fs.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                    break;
                }
                else {fs.setCursor(Cursor.getDefaultCursor());}

                v++;
            }
        }
    }

    class VerticalBuffer extends Thread{
        FlyingSaucer fs;
        MouseEvent e;
        //List<Rectangle2D> recX;
        List<Rectangle2D> recY;

        public VerticalBuffer(FlyingSaucer fs,MouseEvent e){
            this.fs = fs;
            this.e = e;
        }

        public void run(){
            recY = fs.recList2;
            Iterator <Rectangle2D> recs = recY.iterator();  
            int v = 1;
            while(recs.hasNext()){
                recy = (Rectangle2D.Double) recs.next();
                if(recy.contains(e.getPoint())){
                    System.out.println("Y rectangle detected.."+v);
                    fs.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                    break;
                }
                else {fs.setCursor(Cursor.getDefaultCursor());}

                v++;
            }
        }
    }
}

Answer 1

您的 FlyingSaucer 类不是线程安全的，但您正在从两个不同的线程(Horizo​​ntalBuffer 和 VerticalBuffer)访问它。这可能会导致问题:例如，当 Horizo​​ntalBuffer 尝试获取 FlyingSaucer reclist 时，它可能会获取 null 并引发异常。由于不同步访问也可能出现其他问题。这不是最容易调试的事情:例如，除非您观察控制台，否则您不会知道异常，因为一个线程中的异常不会终止多线程程序。

您可以通过正确同步对 FlyingSaucer 的访问使 FlyingSaucer 线程安全来解决此特定的访问同步问题。但也可能存在其他问题；让多线程应用程序正常工作并不简单，对于 Java 新手来说可能不是最好的方法，正如您所说的那样。

正如其他人在评论中指出的那样，最好的解决方案可能不是多线程。我建议用您的单线程解决方案发布一个新问题，并询问如何加快速度。您可以在该问题中提到多线程，但我建议也对其他解决方案持开放态度。