java - super.run() 调用后，Thread 类中的控制不会返回

Question

我有一个 threadfactory、执行器、线程类和一个可运行类。 这是线程类:(threadsCount 是一个 AtomicInteger，我用它来跟踪创建的线程数)

public void run() {
    try {
        threadsCount.incrementAndGet();
        super.run();
    } finally {
        threadsCount.decrementAndGet();
    }
}

我的可运行类当前尚未实现，但有空的 run() 方法。

当我尝试调用 Executor.execute(new RunnableClazz()) 时，控制权转到这个 Thread 类 - run() 方法，当它遇到 super.run() 时，它转到 RunnableClazz#run() 方法。

这些都很好。但问题是，在 RunnableClazz#run() 完成后，控制不会返回到 Thread 类的“finally” block 。

有什么想法吗？我是否需要在 run() 方法末尾手动终止可运行对象？

public class ThreadAA extends Thread {

private static final AtomicInteger threadsCount = new AtomicInteger();
private static final AtomicInteger threadsCreated = new AtomicInteger();
public static final String DEFAULT_NAME = "ThreadAA";

public ThreadAA(Runnable r)
    {
        this(r, DEFAULT_NAME);
    }
public ThreadAA(Runnable r, String threadName)
    {
        super(r, threadName + "-" + threadsCreated.incrementAndGet());

        setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler()
        {
            public void uncaughtException(Thread t, Throwable e)
            {
                logger.error("Uncaught exception in thread " + t.getName(), e);
            }
        });
    }

@Override
public void run()
    {
        boolean debug = false;
        //just for debug purpose
        debug = true;
        if(debug)
        {
            logger.debug("Running thread " + getName());
        }

        try
        {
            threadsCount.incrementAndGet();
            super.run();
        }
        finally
        {
            threadsCount.decrementAndGet();
            if(debug)
            {
                logger.debug("Done running thread " + getName());
            }
        }
    }

 }

我的RunnableClass:

public class RunnableClazz implements Runnable {

@Override
public void run() {
        logger.debug("Inside RunnableClazz");
}

}

调用此可运行的方法如下所示:

  Executor executor = new Executor(25, 100, 1L, TimeUnit.SECONDS, 
                new ArrayBlockingQueue<Runnable>(5), new TFactory("abc"));

    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());        
    executor.execute(new RunnableClazz());  

executor.execute(new RunnableClazz());

请注意，我在服务器启动期间只创建了一次执行器。我粘贴它只是为了提供有关如何创建它的想法。 因此 executor.execute(new RunnableClazz()); 会产生问题。

Answer 1

我复制了您的代码并开始调试。

当你调用 super.run() 时，它会运行 ThreadPoolExecutor 中的一个:

    public void run() {
        runWorker(this);
    }

runWorker 然后调用 RunnableClazz.run()，完成后，它会暂停线程，等待新的 runnable 被执行。这是怎么发生的？

在 threadFactory 中，我认为它是这样的:

public Thread newThread(Runnable r) {
    return new ThreadAA(r);
}

Runnable r 不是您的 RunnableClazz，而是 ThreadPoolExecutor。

编辑:

您可能想要扩展 ThreadPoolExecutor 类并实现方法:

protected void beforeExecute(Thread t, Runnable r) { }

protected void afterExecute(Runnable r, Throwable t) { }

并在那里实现计数。