Question

我有两个名为Reader和Worker的java类。 Reader从文本文件中读取字符串，并将这些字符串传递给Workers，这些字符串将这些字符串排序为树。所以我创建了许多Worker-threads和1个Reader-thread：

        try {      

        /* Create and run worker processes. */
        workers = new TrieWorker[numberOfWorkers];
        for(int i = 0; i < numberOfWorkers; i++)
        {
            workers[i] = new TrieWorker(this);
            new Thread(workers[i]).run();
        }

        /* Create and run reader process. */
        reader  = new TrieReader(this, filename);                        
        new Thread(reader).run();

    } catch(Exception e) {
        e.printStackTrace();
    }

当我的Reader从run（） - 方法中的文本文件中读取字符串时，它通过调用

将字符串传递给其中一个worker

workers[i].add(string);

在调用此方法之前，工作人员基本上什么都不做。所以我想知道，Reader在将此参数传递给其中一个Worker之后会立即继续从文本文件中读取吗？或者只有在完成字符串后，它才会从此方法返回？换句话说，当一个Thread将参数传递给另一个时，除非Thread传递参数需要某种回答，否则它们都会继续做自己的事情吗？

希望你们知道我的意思，真的很难解释。

编辑：感谢您的好答案！这是Reader类的代码：

private static int numberOfNextWorker = 0;

    public void run() 
{
    System.out.println("Reader run.");

    try {
        System.out.println("Reading " + filename);
        read();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

public void read() throws Exception
{
    File file = new File(filename);
    Scanner reader = new Scanner(file);

    if(file.canRead() == false)
        throw new Exception("file " + filename + " cannot be read.");

    long totalLength = file.length();

    while(reader.hasNextLine())
    {

            String text = reader.nextLine();          
            numberOfLines++;

            /* Passes the work on to workers. */
            if(numberOfNextWorker == (numberOfWorkers - 1))
                 numberOfNextWorker = 0;
            else
                 numberOfNextWorker++;

            workers[numberOfNextWorker].add(text); 
        }
}

在这里工人：

    public void run() 
{
    System.out.println("Worker run.");
}

void add(String text) 
{
    numberOfStrings++;
    char[] chars = text.toCharArray();

    int i = 0;
    Node node = new Node();

    while (chars.length > i) {
        node.value = chars[i];
        node = node.children;
        i++;
    }
}

它没有做任何明智的事:)我想我理解你所说的。我已经阅读了很多关于并发性的书，并在纸上做了一些练习，但没有尝试过那么多的代码。

Answer 1

请注意，您不是在任何时候启动新线程，而只是在同一个线程上调用run（）方法。

您需要致电start()以产生新线程，例如：

new Thread(workers[i]).start();

而不是

new Thread(workers[i]).run();

线程如何继续工作取决于您的实现。

Answer 2

对Worker.add的调用是阻塞的，所以它等待add（）完成。这一切都在线程1中运行。如果Worker.add只是将工作添加到工作列表中，并且在run（）方法中处理它的工作（在自己的线程中执行）。

这是一个典型的消费者/生产者问题。（阻止）队列可能会帮助你。

Answer 3

您需要一个名为resource的第三个类。您的线程将通过共享资源进行通信。想想生产者 - 消费者你的工作者将添加到sortedReult。

public class Resource{
  Queue<String> semaphore = new LinkedList<String>();
  Queue<String> sortedResult = new LinkedList<String>();

  public synchronized addStrings(List<String> words){//for reader
    semaphore.addAll(words);
    notify();
  }//

  public synchronized String getString(){//for workers
    while(semaphore.isEmpty())
       try{ wait();}
       catch(InterruptedException e){}
    return semaphore.remove();
  }
}

顺便说一句，你调用run（）表明你有点理解逻辑。但是在Java中，你必须调用start（）并让start（）为你调用run（）。

Java：将参数传递给另一个线程的线程

3 个答案: