Java执行器，无法对任务进行排队

我需要一个Java执行器，它在处理其他任务时拒绝任务。我想不可能控制工作队列的大小

有人可能会想，为什么我一开始就需要一个具有这种特征的遗嘱执行人。我需要能够轻松更改策略并允许非零队列大小

有什么想法吗？

使用。将任务提交给执行器之前，请调用

getActiveCount（）

，并检查它是否等于池大小（表示所有线程都处于活动状态）。如果有，就不要提交任务。

使用a和a（复制自）

这似乎是可行的：

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class SingleTaskExecutor {

public static void main(String[] args) {

    try {
        new SingleTaskExecutor().runTest();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void runTest() throws Exception {

    ThreadPoolExecutor tp = new ThreadPoolExecutor(1, 1,
            60L, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());

    tp.setRejectedExecutionHandler(new RejectedTaskHandler());

    final Semaphore oneTaskDone = new Semaphore(0);
    tp.execute(new Runnable() {
        @Override public void run() { 
            System.out.println("Sleeping");
            try { Thread.sleep(300); } catch (Exception e) { e.printStackTrace();} 
            System.out.println("Done sleeping");
            oneTaskDone.release();
        }
    });
    tp.execute(new Runnable() {
        @Override public void run() { System.out.println("Never happends"); }
        @Override public String toString() { return "Rejected Runnable"; }
    });
    oneTaskDone.acquire();
    tp.execute(new Runnable() {
        @Override public void run() { System.out.println("Running"); }
    });
    tp.shutdown();
    tp.awaitTermination(100, TimeUnit.MILLISECONDS);
    System.out.println("Finished");
}

static class RejectedTaskHandler implements RejectedExecutionHandler {

    @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task rejected: " + r);
    }

}

}

import java.util.concurrent.RejectedExecutionHandler；
导入java.util.concurrent.Semaphore；
导入java.util.concurrent.SynchronousQueue；
导入java.util.concurrent.ThreadPoolExecutor；
导入java.util.concurrent.TimeUnit；
公共类单任务执行器{
公共静态void main（字符串[]args）{
试一试{
新的SingleTaskExecutor（）.runTest（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
public void runTest（）引发异常{
ThreadPoolExecutor tp=新的ThreadPoolExecutor（1，1，
60升，时间单位。秒，
新建SynchronousQueue（））；
setRejectedExecutionHandler（新的RejectedTaskHandler（））；
最终信号量oneTaskDone=新信号量（0）；
tp.execute（新的Runnable（）{
@重写公共void run（）{
System.out.println（“睡眠”）；
尝试{Thread.sleep（300）；}catch（异常e）{e.printStackTrace（）；}
System.out.println（“完成睡眠”）；
oneTaskDone.release（）；
}
});
tp.execute（新的Runnable（）{
@重写public void run（）{System.out.println（“永不发生”）；}
@重写公共字符串toString（）{return“Rejected Runnable”；}
});
oneTaskDone.acquire（）；
tp.execute（新的Runnable（）{
@重写public void run（）{System.out.println（“Running”）；}
});
tp.shutdown（）；
tp.等待终止（100，时间单位毫秒）；
系统输出打印项次（“完成”）；
}
静态类RejectedTaskHandler实现RejectedExecutionHandler{
@重写公共void rejectedExecution（Runnable r、ThreadPoolExecutor executor）{
System.out.println（“任务被拒绝：+r”）；
}
}
}

来自您的声明

---

一次一个。此外，如果执行待定，则应拒绝其他提交

我的结论是

一次只处理一个任务，并在当前任务处理过程中拒绝其他任务是您的要求。在这种情况下，下面的代码应该完成这项工作

BlockingQueue queue = new ArrayBlockingQueue(1);
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, queue, 
ThreadPoolExecutor.DiscardPolicy);

// Submit Your callable task
executor.submit(yourCallableTask);

---

我必须使getActiveCount（）和提交原子。没有这样的锁定是可能的吗？我认为没有锁定是不可能的。即使这种功能已经实现，它仍然会使用锁定（以确保线程安全行为）。对getActiveCount（）+提交使用同步块，您应该不会有问题。所以您的执行者应该只执行一个任务？在给定时间执行一个任务。此外，如果执行待定，则应拒绝其他提交。