java - Java中如何创建这三个线程

Question

我是线程新手，对它们了解不多，但我主要是在创建它们方面遇到困难。

我创建了一个 GUI 程序，它使用选择排序、插入排序或合并排序对随机生成的整数数组进行重复排序。每次排序都对一个列表进行操作，该列表的大小以 2 的幂为基础。每次排序完成后，会显示已排序的元素数量以及所花费的毫秒数。

我已经完成了 3 个类，它们是合并、选择和插入。

我的合并排序工作正常，但我在选择和插入方面仍然遇到问题。我不确定我的“if”和“else”语句是否不正确，或者线程本身是否错误，但我正在努力解决它们。

这是我在主类(class)中的内容。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.swing.*;
import javax.swing.border.EmptyBorder;

public class Sorter extends JFrame
{
private static final long serialVersionUID = 1L;
private static final int WIDTH = 400;
private static final int HEIGHT = 300;

public static final String SELECTION_SORT_TEXT = "Selection Sort";
public static final String INSERTION_SORT_TEXT = "Insertion Sort";
public static final String MERGE_SORT_TEXT = "Merge Sort";

private JComboBox sortingAlgorithms;
private JTextArea display;
private JButton sortButton;
private JPanel panel;
private JLabel loadingIcon;
private JLabel sort;
private String[] options = {SELECTION_SORT_TEXT, INSERTION_SORT_TEXT, MERGE_SORT_TEXT};

public Sorter()
{
    setTitle("Sorter");
    setSize(WIDTH, HEIGHT);
    setLayout(new BorderLayout());
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    createContents();
    setVisible(true);
}
private void createContents()
{
    //TODO: Implement

    this.panel = new JPanel(new FlowLayout());
    this.display = new JTextArea();
    this.loadingIcon = new JLabel(new ImageIcon("loading.gif"));
    this.sort = new JLabel("Sorting Algorithm");
    this.sortButton = new JButton("Sort");
    this.sortingAlgorithms = new JComboBox<>(options);
    loadingIcon.setSize(25,25);

    display.setBorder(new EmptyBorder(10,10,10,10));

    panel.add(sort);
    panel.add(sortingAlgorithms);
    panel.add(sortButton);
    panel.add(loadingIcon);

    sortButton.addActionListener(new SortButtonListener());

    loadingIcon.setVisible(false);
    display.setEnabled(false);

    setLayout(new BorderLayout());
    add(panel, BorderLayout.NORTH);
    add(display, BorderLayout.CENTER);
}

private class SortButtonListener implements ActionListener
{
    private int[] arr;
    private SortRunnable sr;

    public void actionPerformed(ActionEvent e)
    {
        sr.run();
        ExecutorService es = Executors.newSingleThreadExecutor();
        //TODO: Finish Implementation
        if(e.getSource() == sortButton)
        {
            sortingAlgorithms.setEnabled(false);
            sortButton.setEnabled(false);
            loadingIcon.setVisible(true);
            display.setText("N\t\tRuntime (ms)");             
        }
        arr = new int [2000];
        for(int i = 0; i <= 8; i++)
        {
            arr = new int [(int) Math.pow(2, i) * 1000];
            fillArr();
            sr = new SortRunnable((String) sortingAlgorithms.getSelectedItem(), arr, Sorter.this);
            es.execute(sr);
        }
        Thread sortContext = new Thread(new SortRunnable((String) 
        sortingAlgorithms.getSelectedItem(), arr, Sorter.this));
        sortContext.start();
        es.shutdown();
    }
    /*
    These values are powers of 2 from 0 to 8, times 1000.
     */
    private void fillArr()
    {
        Random r = new Random();
        int n = 0;
        for(int i=0; i<arr.length; ++i)
        {
            arr[i] = r.nextInt();
        }
    }
}
/*
The displayResult method is responsible for adding the provided sort runtime information to
the display. It should also check to see if the final sort runtime information is present. If so,
it should hide the loading gif and enable the JComboBox and sort button.
 */
public synchronized void displayResult(int n, long runtime)
{
    //TODO: Implement
    display.append("\n" + n + "\t\t" + runtime);
}

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

我不太关心上面的内容。我更关心如何在创建这些线程的 SortRunnable 类中创建线程。以下是对本类(class)的期望。

此类包含用于计时和执行所选排序的代码。

• 您可以在排序的开始端和结束端找到调用 System.currentTimeMillis() 之间的差异，以获取其运行时间。

• 在执行搜索之前，在 Runnable 中调用“Thread.yield()”，以确保 GUI 线程具有根据需要更新其显示所需的优先级。

• 排序完成后，应在 GUI 线程中更新显示。这可以通过调用 Sorter 引用上的“displayResult”方法来完成。此调用应在 Runnable 对象的 run 方法中发生，作为参数传递给 SwingUtilities invokeLater 方法，如下所示:

 SwingUtilities.invokeLater(new Runnable() 
 {
 @Override
 public void run() 
 {
   //call Sorter's displayResult method here
 }
 });

这是我需要帮助的代码。

import javax.swing.*;

public class SortRunnable implements Runnable
{

    private String sortingAlgorithm;
    private int[] arr;
    private Sorter sorter;

    public SortRunnable(String sortingAlgorithm, int[] arr, Sorter sorter)
    {
        this.sortingAlgorithm = sortingAlgorithm;
        this.arr = arr;
        this.sorter = sorter;
    }
    @Override
    public void run()
    {
        Thread.yield();
        if(sortingAlgorithm.equals(sorter.MERGE_SORT_TEXT))
        {
            MergeSort.mergeSort(arr);
        }
        Thread.yield();
        if(sortingAlgorithm.equals(sorter.SELECTION_SORT_TEXT))
        {
            SelectionSort.sort(arr);
        }
        Thread.yield();
        if(sortingAlgorithm.equals(sorter.INSERTION_SORT_TEXT))
        {
            InsertionSort.sort(arr);
        }
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                Thread.yield();
                sorter.displayResult(arr.length, System.currentTimeMillis());
            //call Sorter's displayResult method here
            }
        });
    }

}

我只需要有关插入和选择线程的帮助。谢谢你!如果您想了解他们的个人类(class)，以便了解其中的内容，请告诉我。

Answer 1

SwingUtilities.invokeLater 将请求放入 Swing 的事件队列中，以便“在将来的某个时刻”进行处理。 Runnable 出列并在事件调度线程的上下文中执行，这意味着您的排序与 UI 在同一线程中运行，并将阻止它直到完成。

现在，事情变得非常复杂。 Swing 不是线程安全的(意味着您不应该从事件调度线程上下文之外更新 UI)并且是单线程的，这意味着任何长时间运行或阻塞操作都会阻止 UI 更新。

“长”的答案是，使用专为此工作而设计的 SwingWorker。不过，您可以继续使用您的代码，但它有点困惑。

您需要捕获更多详细信息，例如排序何时开始以及排序何时结束。然后，您需要计算这两个时间点之间的差异(以毫秒为单位)。

您“可能”有很多方法可以做到这一点，但由于 Java 现在提供了一个很好的新日期/时间 API，您不妨开始使用它。

此信息随后会传递回 UI，可能类似于...

public class SortRunnable implements Runnable
{

    private String sortingAlgorithm;
    private int[] arr;
    private Sorter sorter;

    public SortRunnable(String sortingAlgorithm, int[] arr, Sorter sorter)
    {
        this.sortingAlgorithm = sortingAlgorithm;
        this.arr = arr;
        this.sorter = sorter;
    }
    @Override
    public void run()
    {
        LocalDateTime startTime = LocalDateTime.now();
        MergeSort.mergeSort(arr);
        LocalDateTime endTime = LocalDateTime.now();
        long diff = ChronoUnit.MILLIS.between(startTime, endTime)
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                sorter.displayResult(arr.length, diff);
            }
        });
    }

}

好吧，下一个问题是您没有使用 ExecutorService。

首先，它确实应该是一个实例字段，因为您不需要不断创建它的更多实例。

其次，你的逻辑很困惑，基本上你想要...

1. 创建排序器的实例
2. 填充数组
3. 创建 SortRunnable 的实例
4. 将 SortRunnable 提交给 ExecutorService，以便可以执行它...

也许更像是......

private ExecutorService es = Executors.newSingleThreadExecutor();
public void actionPerformed(ActionEvent e)
{
    fillArr();
    Sorter sorter = null;
    String algorthim = null;
    if(e.getSource() == options[0])
    {
        // create the instance of Sorter to be used...
        sorter = ...
        algorthim = ...
    }
    if(e.getSource() == options[1])
    {
        // create the instance of Sorter to be used...
        sorter = ...
        algorthim = ...
    }
    if(e.getSource() == options[2])
    {
        // create the instance of Sorter to be used...
        sorter = ...
        algorthim = ...
    }
    if (sorter != null) {
        SortRunnable sr = new SortRunnable(algorthim, arr, sorter)
        es.submit(sr);
    }