相关疑难解决方法(0)

我需要一次执行4个任务,如下所示:

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
    taskExecutor.execute(new MyTask());
}
//...wait for completion somehow

一旦完成所有内容,我该如何收到通知？现在我想不出比设置一些全局任务计数器更好的事情,并在每个任务结束时减少它,然后在无限循环中监视这个计数器变为0; 或获得一个Futures列表,并在无限循环监视器isDone中为所有这些.什么是更好的解决方案不涉及无限循环？

谢谢.

我正在使用AsyncTasks来获取数据以响应用户按下按钮.这很好用并且在获取数据时保持接口响应,但是当我检查Eclipse调试器中发生了什么时,我发现每次AsyncTask创建一个新的(这通常是因为它们只能使用一次),正在创建一个新线程,但从未终止.

结果是大量的AsyncTask线程就坐在那里.我不确定这在实践中是否是一个问题,但我真的想摆脱那些额外的线程.

我怎么能杀死这些线程？

在过去的几个小时里,我正在阅读相当多shutdown()的内容ExecutorService,除非我们有一个庞大的应用程序存储,几十个和几十个不使用的不同的执行程序服务,我根本看不出有任何理由(有正当理由).很长时间.

关闭所做的唯一事情(从我收集的内容)是正常线程完成后所做的事情.当普通的Thread完成Runnable(或Callable)的run方法时,它将被传递给Garbage Collection进行收集.使用Executor Service,线程将被暂停,不会为垃圾收集打勾.为此,需要关机.

好的,回到我的问题.是否有任何理由ExecutorService经常或甚至在提交一些任务后立即调用关机？我想留下有人正在做的情况,并在调用之后,awaitTermination()因为这是有效的.一旦我们这样做,我们必须重新创建一个新的ExecutorService,做同样的事情.是不是ExecutorService重用线程的整个想法？那么为什么要ExecutorService这么快就毁灭呢？

简单地创建ExecutorService(或依赖于你需要的数量)是不是一种合理的方式,然后在应用程序运行期间,一旦它们出现就将任务传递给它们,然后在应用程序出口或其他一些重要阶段关闭那些执行程序？

我想从一些经验丰富的编码员那里回答,他们使用ExecutorServices写了很多异步代码.

第二个问题,与平台有点小的交易.如果你们中的一些人会说每次关闭执行程序并不是最好的想法,并且你在android上编程,你能不能告诉我当你处理不同的事件时你如何处理这些关闭(具体来说 - 当你执行它们时)应用生命周期.

由于CommonsWare的评论我发布了中立的帖子.我真的没有兴趣争论死亡,似乎它在那里领先.如果他们愿意分享他们的经验,我只对从经验丰富的开发者那里了解我的问题感兴趣.谢谢.

我想创建一些Producer/Consumer线程应用程序.但我不确定在两者之间实现队列的最佳方法是什么.

所以我有两个想法(两者都可能是完全错误的).我想知道哪个更好,如果它们都吮吸那么什么是实现队列的最佳方式.这主要是我在这些例子中实现的队列,我很关心.我正在扩展一个内部类的Queue类,并且是线程安全的.以下是两个示例,每个示例包含4个类.

主类 -

public class SomeApp
{
    private Consumer consumer;
    private Producer producer;

    public static void main (String args[])
    {
        consumer = new Consumer();
        producer = new Producer();
    }
} 

消费者类 -

public class Consumer implements Runnable
{
    public Consumer()
    {
        Thread consumer = new Thread(this);
        consumer.start();
    }

    public void run()
    {
        while(true)
        {
            //get an object off the queue
            Object object = QueueHandler.dequeue();
            //do some stuff with the object
        }
    }
}

制片人类 -

public class …

每当我打电话shutdownNow()或shutdown()不关机时.我读到了一些线程,它说不能保证关闭 - 有人能为我提供一个好方法吗？

有什么区别

ExecutorService eService = Executors.newFixedThreadPool(2);
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.awaitTermination(1, TimeUnit.NANOSECONDS);
eService.shutdown();

和

eService.shutdown();
eService.awaitTermination(1, TimeUnit.NANOSECONDS);

我真的不明白shutdown().此方法不会等待先前提交的任务完成执行.这是否意味着shutdown()可以终止已提交但未完成的任务？我尝试了一些例子,他们没有证明,请举个例子.

我有以下代码片段,它基本上扫描需要执行的任务列表,然后将每个任务提供给执行程序执行.

该JobExecutor反过来又创造了另一个执行人(做数据库的东西...读取和写入数据队列),并完成任务.

JobExecutor返回Future<Boolean>提交的任务.当其中一个任务失败时,我想优雅地中断所有线程并通过捕获所有异常来关闭执行程序.我需要做哪些改变？

public class DataMovingClass {
    private static final AtomicInteger uniqueId = new AtomicInteger(0);

  private static final ThreadLocal<Integer> uniqueNumber = new IDGenerator();   

  ThreadPoolExecutor threadPoolExecutor  = null ;

   private List<Source> sources = new ArrayList<Source>();

    private static class IDGenerator extends ThreadLocal<Integer> {
        @Override
        public Integer get() {
            return uniqueId.incrementAndGet();
        }
  }

  public void init(){

    // load sources list

  }

  public boolean execute() {

    boolean succcess = true ; 
    threadPoolExecutor = new ThreadPoolExecutor(10,10,
                10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1024), …

我有一个多线程java项目,我想添加一个方法stop()来停止所有正在运行的线程.问题是这个项目是由其他人开发的,我不熟悉它如何实现多个线程.

我所知道的是,一旦项目开始,就会调用许多线程并且它们会永远运行.有没有办法找到所有正在运行的线程并阻止它们？我搜索了很多,并找到了如何获取正在运行的线程列表:

Set<Thread> threadSet = Thread.getAllStackTraces().keySet();

下一步要做什么来阻止所有正在运行的线程？

我想要停止这些线程的原因是我需要将此项目作为一个包部署到OSGi容器.捆绑包启动后,多个线程将永远运行.所以我需要实现一个destroy()方法来阻止所有线程来控制bundle的生命周期.

怎么样

for (Thread t : Thread.getAllStackTraces().keySet()) 
{  if (t.getState()==Thread.State.RUNNABLE) 
     t.interrupt(); 
} 

for (Thread t : Thread.getAllStackTraces().keySet()) 
{  if (t.getState()==Thread.State.RUNNABLE) 
     t.stop(); 
}

我有一个ExecutorService：

private final ExecutorService listenDataExecutorService = 
                              Executors.newSingleThreadExecutor();

在同样的情况下，我需要执行人停止做他的工作。为此我打电话listenDataExecutorService.shutdown();

然后过了一段时间，我需要这个执行者再次做这项工作。但是当我调用时listenDataExecutorService.execute()抛出异常。

之后如何为执行者执行新任务shutdown？

我的代码:

String[] torrentFiles = new File("/root/torrents/").list();

        if(torrentFiles.length == 0 || torrentFiles == null)
        {
            System.exit(0);
        }

        ex = Executors.newFixedThreadPool(3);

        for(String torrentFile : torrentFiles)
        {
            ex.submit(new DownloadTorrent("/root/torrents/" + torrentFile));
        }

        ex.shutdown();

        try
        {
            ex.awaitTermination(30, TimeUnit.MINUTES);
        }
        catch(InterruptedException ex1)
        {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex1);
        }

但有时洪流下载需要未知的时间价值,« awaitTermination»不能按我的意愿工作.我需要在半小时后立即停止所有执行的线程,但据我所知« awaitTermination»只使用interrupt()仅在循环或等待中工作的方法.如果这一刻发生,超时不起作用.那么,怎么样？

我想按下按钮时运行一个线程

public void ButtonClick(){

    Thread thread = new Thread(){
        public void run(){
            Log.i("Test", "I'm in thread");
        }
    };
    thread.start();
}

我的问题是:我想在此按钮上多次单击.在打印"我在线程中"消息后,是否还存在多个线程？或者每次运行函数完成时,线程都会被销毁？

如果我创建了几个同时运行的线程,我怎样才能以干净的方式关闭它们？

谢谢你的帮助!

我有一个ExecutorService executor = Executors.newSingleThreadExecutor();我想停止服务器关闭时.

我有一个课程,implements ServletContextListener并注明了它@WebListener.

我在该课程中有两种方法:

@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
    System.out.println("ServletContextListener started");
}

@Override
public void contextDestroyed(ServletContextEvent servletContextEvent) {
    executor.shutdown();
    executor.shutdownNow();
    System.out.println("ServletContextListener destroyed");
}

而且我看到它在它们应该的时候打印出它们中的内容,但是当我在intelij中按下一次停止按钮时,我得到:

严重:Web应用程序[]似乎已启动一个名为[pool-2-thread-1]的线程但未能阻止它.这很可能造成内存泄漏.

印刷后立即ServletContextListener destroyed.

我需要再次按下停止按钮才能完全停止它.

为什么它不会关闭ExecutorService即使它到达了executor.shutdown();？我究竟做错了什么？

PS:这是我唯一的ExecutorService,没有其他线程由我制作.

EDIT2:

执行程序服务是单例类中的一个字段,它使用类初始化:

private ExecutorService executor = Executors.newSingleThreadExecutor();

这是类的初始化方式(延迟初始化):

public static RoomsManager getRoomsManager(ServletContext servletContext) {
    if (servletContext.getAttribute(MANAGER_GAMES_ATTRIBUTE_NAME) == null) {
        servletContext.setAttribute(MANAGER_GAMES_ATTRIBUTE_NAME, new RoomsManager());
    }
    return (RoomsManager)servletContext.getAttribute(MANAGER_GAMES_ATTRIBUTE_NAME);
}

并注释如下:

@WebListener
public class RoomsManager  implements ServletContextListener {

停止按钮是intelij IDEA中播放和调试按钮附近的红色方块.

有没有办法通过一个巨大的数据库并并行应用一些工作来获取条目？我尝试使用 ExecutorService，但我们必须关闭（）才能知道池大小......

所以我最好的解决方案是：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestCode
{
private static List<String> getIds(int dbOffset, int nbOfArticlesPerRequest) 
{
    return Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29");
}

public static void main(String args[]) throws Exception
{
    int dbOffset = 0;
    int nbOfArticlesPerRequest = 100;
    int MYTHREADS = 10;
    int loopIndex = 0;
    boolean bContinue=true; …