标签: executorservice

我想安排一项任务首先经常发生,然后不经常发生.我宁愿不为此添加一个依赖到Quartz.

使用标准Java库,我提出的最好的是一系列一次性任务,然后是一个不太频繁的线性计划:

    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    myRunnable = new MyRunnable();
    executor.schedule( myRunnable, 0, TimeUnit.SECONDS );
    executor.schedule( myRunnable, 5, TimeUnit.SECONDS );
    executor.schedule( myRunnable, 10, TimeUnit.SECONDS );
    executor.schedule( myRunnable, 15, TimeUnit.SECONDS );
    executor.schedule( myRunnable, 30, TimeUnit.SECONDS );
    executor.schedule( myRunnable, 45, TimeUnit.SECONDS );
    executor.scheduleWithFixedDelay( myRunnable, 60, 300, TimeUnit.SECONDS );

有更优雅的方法吗？

我正在寻找一个简单的生产者 - Java 中的消费者实现，不想重新发明轮子

我找不到同时使用新并发包和 Piped 类的示例

是否有为此使用PipedInputStream和新的 Java 并发包的示例？

有没有更好的方法而不使用 Piped 类来完成这样的任务？

我想从队列中提取多个文件并同时解析它们.但是,我的执行者只调用一个线程:

private static ScheduledExecutorService parsingExec ;
protected static BlockingQueue<Path> queue = new LinkedBlockingQueue<>();
int threadPoolSize = 10;
parsingExec = Executors.newScheduledThreadPool(threadPoolSize);
parsingExec.scheduleAtFixedRate(new MyParser(queue), 0, 0, TimeUnit.MILLISECONDS);

在我之前的问题中，我正在做一个简单的练习，观察目录中的文件更改。我从这个 oracle docs 中获取了代码，它没有问题，除了我不确定的小未经检查的强制转换警告。

我对这段代码的下一个问题是它在线程中放置了一个硬循环，这至少在理论上是阻塞的。现在，我知道如果操作系统使用时间切片，即使是硬循环也会被分成小块，这些小块与应用程序正在运行的其他线程共享处理器的时间，事实上我可以制作各种硬循环的例子在不同的线程中运行不会互相阻塞（只要它们具有相同的优先级），即使是在一个明确创建的只有一个内核的虚拟机上。

但是，Java 语言不保证它使用哪种调度来管理线程，如果是时间片还是轮询；这取决于实际的 VM 实现和操作系统。所以我在学习这个主题时得到的建议是编写代码，就好像它必须在循环线程调度上运行一样，从而避免在线程中放置硬循环，除非我的代码可以不断地将控制权交还给其他线程与sleep()、wait()、yeld()等（我可以想到一个 GUI，其中主线程是一个硬循环监视事件，并将控制权发送回侦听器来处理它们的线程）。

但是，在我的情况下，我想不出一种方法在处理文件更改后让线程进入睡眠状态，或者将控制权返回主循环，因为核心思想基本上是不断询问是否有对文件系统的更改。所以我想到的是一个定期调用监视线程的预定执行程序。显然，这是在拥有“阻塞”线程和在发生文件系统更改时立即得到通知之间的权衡。由于在实际情况下我将进行此练习，因此我可能不需要立即通知，我对此很满意。代码非常简单：

// imports...
public class Main
{
    public static FileSystem fs;
    public static Path dir;
    public static WatchService watcher;
    public static WatchKey key;

    public static void main(String[] args)
    {
        fs = FileSystem.getDefault();
        dir = fs.getPath(".");

        try {
            watcher = fs.newWatchService();
            dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
        } catch (IOException e) {
            System.err.println(e.getMessage());
            return;
        }

        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable()
            {
                public void run()
                {
                    Main.key = Main.watcher.poll(); …

我正在阅读有关命令模式的信息，并且试图找出它在 JDK 中的实现。我认为执行器服务是命令模式的一种实现。哪位专家可以确认一下吗？

为什么我在下面的代码中没有将 list1 和 list2 的列表大小设置为 1000：

https://pastebin.com/ttcbkjqR

我的主要方法代码如下：

    ExecutorService executor = Executors.newFixedThreadPool(2);

    for(int j=0; j<2; j++) {
        executor.submit(new Worker(j));
    }

    executor.shutdown();
    System.out.println("All tasks submitted: ");

    try {
        executor.awaitTermination(1, TimeUnit.DAYS);
    } catch (InterruptedException e) {

    }
    long end = System.currentTimeMillis();
    System.out.println("Time taken: " + (end - start));
    System.out.println("List1: " + list1.size() + "; List2: " + list2.size());

在这里Worker上课：

class Worker implements Runnable{
    private int id;
    
    public Worker(int id) {
        this.id = id;
    }

    private Random random = new Random(); …

我有一个简短的 java 程序，它创建了一个单线程调度执行器，并调度了一个任务。

ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

scheduledExecutorService.schedule(cloudWatchReporter, accumulateForMillis, TimeUnit.MILLISECONDS);

在预定时间到来之前，我的主线程结束，JVM 退出。我原以为它会在关闭之前等待计时器完成并执行计划任务。这不是发生的事情。如果我在主线程结束之前添加了足够的睡眠，那么我的任务将在 JVM 关闭之前执行。

Executors 是否有管理计时器的主线程？还是通过其他方式实现了定时器效果？如果由某个主线程管理，它是守护线程还是非守护线程？

我需要定期调用一个方法而不使用Timer类.该方法将由多线程调用.