首先，我以前从未使用过线程，所以请原谅任何松散的术语。我有三个相似但不同的类，所有这些类都需要从互联网上读取信息，所以我想创建一个在后台运行的线程，而程序使用它在线的本地副本。但是，每个类都需要自己的特殊输入，因此我不能制作一个主要的可运行类。
问题：我应该创建三个单独的线程，每个程序一个，还是可以在每个类中嵌入一个可运行线程？我该怎么做？
谢谢您的帮助
附言。如果您想查看我的程序（至少是它的一个版本），请访问 jacobfakult.50webs.com/quizzes/program...抱歉广告，再次感谢！
由于您以前从未使用过线程，因此我不会直接回答您，因此我建议您先阅读有关此主题的内容。这是官方资源：课程：并发和执行器。
在阅读完所有这些之后，您现在将了解您想要使用一个ExecutorService将为您处理线程的线程。现在唯一重要的是当前应用程序设计将在每个线程上完成工作，在这种情况下，从互联网下载内容。
简单的方法：让你的三个（或更多）类实现Runnable接口并完成run方法中的所有工作。例子：
public class Foo implements Runnable {
@Override
public void run() {
doWork();
}
public void doWork() {
//download files or whatever you want/need to do
}
}
public class BigWorker {
private static final int NUM_OF_THREADS = 3;
public void doWork() {
ExecutorService es = Executors.newFixedThreadPool(NUM_OF_THREADS);
es.execute(new Foo());
//assuming Bar and Baz are the other two classes...
es.execute(new Bar());
es.execute(new Baz());
//it is A MUST to call this method
es.shutdown();
}
}
/*
* i dont understand totally what your point is, but assume
* we have 3 classes that needs to use one Runnable task ...
* Threads are Runnable ... any way, so
*/
// create your runnable task
class ReadDataOnline implements Runnable{
@Override
public void run() {
// read data from the internet and update something or what ever
}
}
// create your classes that will use this task
class ClassOne{
private ReadDataOnline runnable = null;
private Thread reader = null;
ClassOne(ReadDataOnline runnable){
this.runnable = runnable;
reader = new Thread(runnable);
}
void useTask(){
// start your new Thread in the background, which will use
// the Runnable task in the parameter
reader.start();
}
}
class ClassTwo {
private ReadDataOnline runnable = null;
private Thread reader = null;
ClassTwo(ReadDataOnline runnable) {
this.runnable = runnable;
reader = new Thread(runnable);
}
void useTask() {
// start your new Thread in the background, which will use
// the Runnable task in the parameter
reader.start();
}
}
class ClassThree {
private ReadDataOnline runnable = null;
private Thread reader = null;
ClassThree(ReadDataOnline runnable) {
this.runnable = runnable;
reader = new Thread(runnable);
}
void useTask() {
// start your new Thread in the background, which will use
// the Runnable task in the parameter
reader.start();
}
}
class MainClass{
public void doStuff(){
ReadDataOnline runnable = new ReadDataOnline();
// use the same runnable task in the three classes
ClassOne classOne = new ClassOne(runnable);
ClassTwo classTwo = new ClassTwo(runnable);
ClassThree classThree = new ClassThree(runnable);
// let classOne start using the Task
classOne.useTask();
// now the Task status is updated/modified by classOne,
// let classTwo use the task in it's new state
classTwo.useTask();
// and so on
classThree.useTask();
/*
* since we are not talking about a specefic case, i cant tell
* what is the task or what to do with it, but put in mind that
* synchronizing your methods is very important since multi-threading
* doesnt guarantee the order of the threads, and also they wont
* be synchronized with each other unless your methods are synchronized
* (or you use synchronization blocks)
*/
// i know this example isnt very good, but at least it shows how to use
// the same task in multiple Threads or classes that are backed with
// different threads
}
}
我对这个主题不太熟悉，但这是我的两分钱（免费）：
经过一番谷歌搜索后，您可以拥有的线程数量似乎没有限制，但是线程数量越多，每个线程提供的好处就越低。在我看来，一个线程就足以完成您的任务。
例子：
//maybe make an Request class that specifies the url of what you want to download,
//and what to do with response
//put this ArrayList as a member field in the class you are making the thread
ArrayList<Request> requests = new ArrayList<Request>();
Thread backgroundThread = new Thread(){
public void run(){
while(true)
{
if(requests.size() > 0)
{
Request oldestRequest = requests.get(0);
//process the request
test.remove(0);
}
else
{
//checks every 10 seconds if there is a request
Thread.sleep(10000);
}
}
}
};
backgroundThread.start();