我必须编写一个程序来搜索文件中的一堆行并尝试找到给定的子字符串。如果找到它，就会打印出该行。我读取的每一行都创建为一个线程，每个线程搜索文件的一行。到目前为止这还不是问题。我需要程序做的是按照创建线程的顺序打印最终结果（文本行）。 IE。线程 6 不应该在线程 2 之前打印。线程可以同时运行，只需保持打印顺序即可。我无法使用 join 方法，因为我不希望下一个方法在开始之前等待另一个方法完全完成，我确实希望它们同时运行。对这样做有什么建议吗？另外，该文件可以有任意数量的行，因此我无法对线程数进行硬编码。
线程应该自己打印。 主要不进行打印。
首先，线程应用程序的顺序很难定义。请参阅此处：多线程中不需要的输出
如果您希望按特定顺序输出，那么您可能应该使用
ExecutorServiceFutureCallable<String>Future<String>get()Future// create a thread pool with 10 workers
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// or you can create an open-ended thread pool
// ExecutorService threadPool = Executors.newCachedThreadPool();
// define your jobs somehow as a Callable that returns the line (prolly string)
List<Future<String>> futures = threadPool.invokeAll(jobsToDo);
// once we have submitted all jobs to the thread pool, it should be shutdown
threadPool.shutdown();
// now we can go through the futures and get the results in order
for (Future<String> future : futures) {
// this returns the results from the `call()` in order or it throws
String resultFromCall = future.get();
}
你的工作
Callablepublic class MyCallable implements Callable<String> {
private String input;
public MyCallable(String input) {
this.input = input;
}
public String call() {
// search the input string
String result = search(input);
return result;
}
}
实际上，您可以使用
join() 中的实用程序类编写。 但是，我使用线程“基类”编写了这个示例来帮助学习。 请注意 reggert 的评论（上面）——盲目地在文件中的每一行文本创建一个线程可能会导致线程过多，从而导致程序崩溃或操作系统不堪重负。 这种工作委托最好使用线程池来完成（例如 java.util.concurrent.Executors）。
public class MultiThreadedLineSearcher {
public static void main(String[] args) throws Exception {
Thread previousThread = null;
for (int i = 0; i < LINES.length; i++) {
JobRunnable job = new JobRunnable(i, LINES[i], previousThread);
Thread thread = new Thread(job, "T-" + i);
thread.start();
previousThread = thread;
}
if (previousThread != null) {
previousThread.join();
}
System.out.println("Program done.");
}
public static class JobRunnable implements Runnable {
private final int _lineIdx;
private final String _lineText;
private final Thread _threadToWaitForBeforePrinting;
public JobRunnable(int lineIdx, String lineText,
Thread threadToWaitForBeforePrinting) {
_lineIdx = lineIdx;
_lineText = lineText;
_threadToWaitForBeforePrinting = threadToWaitForBeforePrinting;
}
public void run() {
try {
boolean matched = FIND_ME.matcher(_lineText).find();
String currentThreadName = Thread.currentThread().getName();
System.out.println("Thread " + currentThreadName
+ " is done with its work.");
if (_threadToWaitForBeforePrinting != null) {
System.out.println("Thread " + currentThreadName
+ " will wait for thread "
+ _threadToWaitForBeforePrinting.getName()
+ " before printing its results.");
_threadToWaitForBeforePrinting.join();
}
System.out.println("RESULT: " + _lineIdx + " matched? "
+ matched + " (Printed on Thread "
+ currentThreadName + ")");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
final static String[] LINES = new String[] {
"Sed ut perspiciatis unde omnis iste natus error sit voluptatem",
"accusantium doloremque laudantium, totam rem aperiam, eaque ipsa",
"quae ab illo inventore veritatis et quasi architecto beatae vitae",
"dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas",
"sit aspernatur aut odit aut fugit, sed quia consequuntur magni",
"dolores eos qui ratione voluptatem sequi nesciunt. Neque porro",
"quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur,",
"adipisci velit, sed quia non numquam eius modi tempora incidunt",
"ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad",
"minima veniam, quis nostrum exercitationem ullam corporis",
"suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur?",
"Quis autem vel eum iure reprehenderit qui in ea voluptate velit",
"esse quam nihil molestiae consequatur, vel illum qui dolorem eum",
"fugiat quo voluptas nulla pariatur?" };
// Match only words that are 11 characters or longer
final static java.util.regex.Pattern FIND_ME =
java.util.regex.Pattern.compile("\\w{11,}");
}
以下是如何使用执行器来完成此操作：
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class MultiThreadedLineSearcherExecutor {
static final int MAX_THREADS = 10;
public static void main(String[] args) throws Exception {
// Create as many threads as there are lines of text,
// but do not exceed 10 threads
int lineCount = LINES.length;
int threadPoolSize = Math.min(MAX_THREADS, lineCount);
System.out.println("Number of lines = " + lineCount);
System.out.println("Thread pool size = " + threadPoolSize);
ExecutorService executor = Executors.newFixedThreadPool(threadPoolSize);
Future previousFuture = null;
for (int i = 0; i < lineCount; i++) {
JobRunnable job = new JobRunnable(i, LINES[i], previousFuture);
previousFuture = executor.submit(job);
}
executor.shutdown();
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
System.out.println("Program done.");
}
public static class JobRunnable implements Runnable {
private final int _lineIdx;
private final String _lineText;
private final Future _futureToWaitForBeforePrinting;
public JobRunnable(int lineIdx, String lineText,
Future previousFuture) {
_lineIdx = lineIdx;
_lineText = lineText;
_futureToWaitForBeforePrinting = previousFuture;
}
public void run() {
try {
boolean matched = FIND_ME.matcher(_lineText).find();
String currentThreadName = Thread.currentThread().getName();
System.out.println("Thread " + currentThreadName
+ " is done with its work on line " + _lineIdx);
if (_futureToWaitForBeforePrinting != null) {
System.out.println("Thread " + currentThreadName
+ " will wait for future "
+ _futureToWaitForBeforePrinting
+ " before printing its results.");
_futureToWaitForBeforePrinting.get();
}
System.out.println("RESULT: " + _lineIdx + " matched? "
+ matched + " (Printed on Thread "
+ currentThreadName + ")");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
final static String[] LINES = new String[] {
"Sed ut perspiciatis unde omnis iste natus error sit voluptatem",
"accusantium doloremque laudantium, totam rem aperiam, eaque ipsa",
"quae ab illo inventore veritatis et quasi architecto beatae vitae",
"dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas",
"sit aspernatur aut odit aut fugit, sed quia consequuntur magni",
"dolores eos qui ratione voluptatem sequi nesciunt. Neque porro",
"quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur,",
"adipisci velit, sed quia non numquam eius modi tempora incidunt",
"ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad",
"minima veniam, quis nostrum exercitationem ullam corporis",
"suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur?",
"Quis autem vel eum iure reprehenderit qui in ea voluptate velit",
"esse quam nihil molestiae consequatur, vel illum qui dolorem eum",
"fugiat quo voluptas nulla pariatur?" };
// Match only words that are 11 characters or longer
final static java.util.regex.Pattern FIND_ME =
java.util.regex.Pattern.compile("\\w{11,}");
}
您可以让它们填充一个数组（每个数组都“知道”要填充的元素，作为其初始状态的一部分），然后加入所有线程，以便您等待它们全部完成，然后就可以了按顺序打印出数组的内容。
Runnable。像这样的东西：
private Map<Integer, String> map = new HashMap<Integer, String>();
int counter = 1;
while (line = getNextLine()) {
Runnable runnable = new PrinterRunnable(line, counter);
++counter;
}
Runnable看起来像：
public PrinterRunnable implements Runnable {
private String line;
private Integer counter;
public PrinterRunnable(String line, Integer counter) {
this.line = line;
this.counter = counter;
}
public run () {
// Do some work on line and keep in the map the result where counter is the key
}
}
重要：在此示例中，PrinterRunnable应该是运行代码的类的内部类，以便它能够访问地图（或者您应该以其他方式传递对地图的引用）。
最后您可以对地图的
keySet()进行排序，然后相应地打印值。