Java 通过正确的列表执行多线程

我对多线程的经验是有限的，所以说实话，这可能是一个糟糕的想法。以下是我想做的：

50个URL的ArrayList（示例） 使用x个线程（例如5个）访问列表中的一系列URL 调用泛型方法来处理URL（检索html） 将结果与其他线程结果一起存储在主列表中

现在我一直在用多个线程处理ArrayList，我目前的想法是将列表除以列表中的URL数量，并为每个线程分配一个数字范围来处理，例如

螺纹1-0-7 螺纹2-8-15

等

我假设这是一个糟糕的方法，但我真的找不到一个示例方法

非常感谢您的帮助/建议

创建一个线程池，每个线程在其中处理一个URL 列表中的时间

保留一个全局索引计数器，以便 线程完成后，它可以从列表中检索要处理的下一个URL

执行此操作直到处理完所有URL，即index==list.size（）

这样，在作业完成之前，所有线程都将得到充分利用。您可以根据池中线程的数量来优化特定运行时环境的性能

只需确保索引计数器代码是线程安全的。：）

创建一个线程池，每个线程在其中处理一个URL 列表中的时间

保留一个全局索引计数器，以便 线程完成后，它可以从列表中检索要处理的下一个URL

执行此操作直到处理完所有URL，即index==list.size（）

这样，在作业完成之前，所有线程都将得到充分利用。您可以根据池中线程的数量来优化特定运行时环境的性能

---

只需确保索引计数器代码是线程安全的。：）

我愿意接受其他选择/批评。。。我不是多线程专家，但在过去我做过类似的事情：

public class MainController {

    public static void main(String[] args) {
        ThreadGroup workers = new ThreadGroup("workers");
        Iterator<String> urls = getUrlList().iterator();
        while(workers.activeCount() < 5 && urls.hasNext()) {
            UrlProcessor proc = new UrlProcessor(urls.next());
            Thread worker = new Thread(workers, proc);
            worker.start();
        }
    }

    private static List<String> getUrlList() {
        return null;  //To change body of created methods use File | Settings | File Templates.
    }
}


public class UrlProcessor implements Runnable {

    private String url;

    public UrlProcessor(String url) {
        this.url = url;
    }

    public void run() {
        // process URL
    }
}

class UrlTask implements Callable<String>{
    final URL url;

    UrlTask(URL url){
        this.url = url;
    }

    public String call(){
         return fetch( url );
    }
}

Collection<Future<String>> results = new Arraylist<Future<String>>();
for( URL each : urls ){
    UrlTask task = new UrlTask( each);
    Future<String> result = executor.submit( task );
    results.add( result );
}

for( Future<String> result : results ){
    String content = result.get();
    // process content
} 

公共类主控制器{
公共静态void main（字符串[]args）{
ThreadGroup workers=新ThreadGroup（“workers”）；
迭代器URL=getUrlList（）.Iterator（）；
while（workers.activeCount（）<5&&url.hasNext（））{
UrlProcessor proc=新的UrlProcessor（url.next（））；
线程工作线程=新线程（工作线程，进程）；
worker.start（）；
}
}
私有静态列表getUrlList（）{
return null；//若要更改已创建方法的主体，请使用文件|设置|文件模板。
}
}
公共类UrlProcessor实现可运行{
私有字符串url；
公共url处理器（字符串url）{
this.url=url；
}
公开募捐{
//进程URL
}
}

我愿意接受其他选择/批评。。。我不是多线程专家，但在过去我做过类似的事情：

public class MainController {

    public static void main(String[] args) {
        ThreadGroup workers = new ThreadGroup("workers");
        Iterator<String> urls = getUrlList().iterator();
        while(workers.activeCount() < 5 && urls.hasNext()) {
            UrlProcessor proc = new UrlProcessor(urls.next());
            Thread worker = new Thread(workers, proc);
            worker.start();
        }
    }

    private static List<String> getUrlList() {
        return null;  //To change body of created methods use File | Settings | File Templates.
    }
}


public class UrlProcessor implements Runnable {

    private String url;

    public UrlProcessor(String url) {
        this.url = url;
    }

    public void run() {
        // process URL
    }
}

class UrlTask implements Callable<String>{
    final URL url;

    UrlTask(URL url){
        this.url = url;
    }

    public String call(){
         return fetch( url );
    }
}

Collection<Future<String>> results = new Arraylist<Future<String>>();
for( URL each : urls ){
    UrlTask task = new UrlTask( each);
    Future<String> result = executor.submit( task );
    results.add( result );
}

for( Future<String> result : results ){
    String content = result.get();
    // process content
} 

公共类主控制器{
公共静态void main（字符串[]args）{
ThreadGroup workers=新ThreadGroup（“workers”）；
迭代器URL=getUrlList（）.Iterator（）；
while（workers.activeCount（）<5&&url.hasNext（））{
UrlProcessor proc=新的UrlProcessor（url.next（））；
线程工作线程=新线程（工作线程，进程）；
worker.start（）；
}
}
私有静态列表getUrlList（）{
return null；//若要更改已创建方法的主体，请使用文件|设置|文件模板。
}
}
公共类UrlProcessor实现可运行{
私有字符串url；
公共url处理器（字符串url）{
this.url=url；
}
公开募捐{
//进程URL
}
}

一种简单得多的方法是只需使用

ExecutorService

按需处理URL，然后使用

Future

s检索结果：

class URLProcessor {

    class ThreadTask implements Callable<String> {
         private String url;

         public ThreadTask(String url) {
             this.url = url;
         }

         public String call() {
             // process url
             // return a String result
         }
    }

...


// input urls
List<String> urls = new ArrayList<String>();
// futures to retrieve task results
List<Future<String>> futures = new ArrayList<Future<String>>();
// results
List<String> results = new ArrayList<String>();
// pool with 5 threads
ExecutorService exec = Executors.newFixedThreadPool(5); 

// enqueue tasks
for(String url: urls) {
    futures.add(exec.submit(new ThreadTask(url)));
}

// wait for tasks to finish
for(Future<String> future: futures) {
    results.add(future.get());
}

类处理器{ 类ThreadTask实现可调用{ 私有字符串url； 公共线程任务（字符串url）{ this.url=url； } 公共字符串调用（）{ //进程url //返回字符串结果 } } ... //输入URL 列表URL=新的ArrayList（）； //检索任务结果的方法 列表期货=新的ArrayList（）； //结果 列表结果=新建ArrayList（）； //5线程池 ExecutorService exec=Executors.newFixedThreadPool（5）； //让任务排队 for（字符串url:url）{ futures.add（exec.submit（newthreadtask（url））； } //等待任务完成 for（未来：未来）{ results.add（future.get（））； }

---

一种简单得多的方法是只需使用

ExecutorService

按需处理URL，然后使用

Future

s检索结果：

class URLProcessor {

    class ThreadTask implements Callable<String> {
         private String url;

         public ThreadTask(String url) {
             this.url = url;
         }

         public String call() {
             // process url
             // return a String result
         }
    }

...


// input urls
List<String> urls = new ArrayList<String>();
// futures to retrieve task results
List<Future<String>> futures = new ArrayList<Future<String>>();
// results
List<String> results = new ArrayList<String>();
// pool with 5 threads
ExecutorService exec = Executors.newFixedThreadPool(5); 

// enqueue tasks
for(String url: urls) {
    futures.add(exec.submit(new ThreadTask(url)));
}

// wait for tasks to finish
for(Future<String> future: futures) {
    results.add(future.get());
}

类处理器{ 类ThreadTask实现可调用{ 私有字符串url； 公共线程任务（字符串url）{ this.url=url； } 公共字符串调用（）{ //进程url //返回字符串结果 } } ... //输入URL 列表URL=新的ArrayList（）； //检索任务结果的方法 列表期货=新的ArrayList（）； //结果 列表结果=新建ArrayList（）； //5线程池 ExecutorService exec=Executors.newFixedThreadPool（5）； //让任务排队 for（字符串url:url）{ futures.add（exec.submit（newthreadtask（url））； } //等待任务完成 for（未来：未来）{ results.add（future.get（））； }

---

为每个URL创建一个任务，并将其提交给执行者

任务可能如下所示：

public class MainController {

    public static void main(String[] args) {
        ThreadGroup workers = new ThreadGroup("workers");
        Iterator<String> urls = getUrlList().iterator();
        while(workers.activeCount() < 5 && urls.hasNext()) {
            UrlProcessor proc = new UrlProcessor(urls.next());
            Thread worker = new Thread(workers, proc);
            worker.start();
        }
    }

    private static List<String> getUrlList() {
        return null;  //To change body of created methods use File | Settings | File Templates.
    }
}


public class UrlProcessor implements Runnable {

    private String url;

    public UrlProcessor(String url) {
        this.url = url;
    }

    public void run() {
        // process URL
    }
}

class UrlTask implements Callable<String>{
    final URL url;

    UrlTask(URL url){
        this.url = url;
    }

    public String call(){
         return fetch( url );
    }
}

Collection<Future<String>> results = new Arraylist<Future<String>>();
for( URL each : urls ){
    UrlTask task = new UrlTask( each);
    Future<String> result = executor.submit( task );
    results.add( result );
}

for( Future<String> result : results ){
    String content = result.get();
    // process content
} 

类UrlTask实现可调用{
最终网址；
URL任务（URL）{
this.url=url；
}
公共字符串调用（）{
返回获取（url）；
}
}

并且使用如下：

public class MainController {

    public static void main(String[] args) {
        ThreadGroup workers = new ThreadGroup("workers");
        Iterator<String> urls = getUrlList().iterator();
        while(workers.activeCount() < 5 && urls.hasNext()) {
            UrlProcessor proc = new UrlProcessor(urls.next());
            Thread worker = new Thread(workers, proc);
            worker.start();
        }
    }

    private static List<String> getUrlList() {
        return null;  //To change body of created methods use File | Settings | File Templates.
    }
}


public class UrlProcessor implements Runnable {

    private String url;

    public UrlProcessor(String url) {
        this.url = url;
    }

    public void run() {
        // process URL
    }
}

class UrlTask implements Callable<String>{
    final URL url;

    UrlTask(URL url){
        this.url = url;
    }

    public String call(){
         return fetch( url );
    }
}

Collection<Future<String>> results = new Arraylist<Future<String>>();
for( URL each : urls ){
    UrlTask task = new UrlTask( each);
    Future<String> result = executor.submit( task );
    results.add( result );
}

for( Future<String> result : results ){
    String content = result.get();
    // process content
} 

Collection results=new Arraylist（）；
for（每个URL:URL）{
UrlTask task=新的UrlTask（每个）；
未来结果=执行者提交（任务）；
结果。添加（结果）；
}
用于（未来结果：结果）{
字符串内容