IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java线程任务案例如何提交执行

wen java案例 215

本文目录导读：

Java线程任务案例如何提交执行

  1. 使用 Thread 类直接创建
  2. 使用线程池 (ExecutorService)
  3. 完整的生产者-消费者案例
  4. 使用 CompletableFuture 实现异步编排
  5. 定时任务执行
  6. 提交任务的常用方法对比

我来介绍Java中提交和执行线程任务的几种主要方式和案例。

使用 Thread 类直接创建

public class ThreadExample {
    public static void main(String[] args) {
        // 方式1：继承Thread类
        Thread thread1 = new MyThread("线程1");
        thread1.start();  // 提交执行
        // 方式2：实现Runnable接口
        Thread thread2 = new Thread(new MyRunnable("线程2"));
        thread2.start();  // 提交执行
        // 方式3：Lambda表达式
        Thread thread3 = new Thread(() -> {
            System.out.println("Lambda线程执行: " + Thread.currentThread().getName());
        }, "线程3");
        thread3.start();
    }
}
class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println("继承Thread类执行: " + getName());
    }
}
class MyRunnable implements Runnable {
    private String name;
    public MyRunnable(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println("实现Runnable接口执行: " + name);
    }
}

使用线程池 (ExecutorService)

固定线程池

import java.util.concurrent.*;
public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 提交Runnable任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("任务" + taskId + " 由 " + 
                                 Thread.currentThread().getName() + " 执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        // 关闭线程池
        executor.shutdown();
    }
}

带返回值的任务 (Callable)

import java.util.concurrent.*;
public class CallableExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 提交Callable任务，返回Future
        Future<Integer> future1 = executor.submit(() -> {
            Thread.sleep(2000);
            return 100;
        });
        Future<Integer> future2 = executor.submit(() -> {
            Thread.sleep(1000);
            return 200;
        });
        System.out.println("提交任务完成，等待结果...");
        // 获取结果（会阻塞）
        Integer result1 = future1.get();  // 等待2秒
        Integer result2 = future2.get();  // 等待1秒
        System.out.println("结果1: " + result1 + ", 结果2: " + result2);
        executor.shutdown();
    }
}

完整的生产者-消费者案例

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class ProducerConsumerExample {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // 共享队列
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);
        AtomicInteger taskCounter = new AtomicInteger(0);
        // 提交生产者任务
        executor.submit(new Producer(queue, taskCounter));
        // 提交消费者任务
        for (int i = 0; i < 3; i++) {
            executor.submit(new Consumer(queue, "消费者" + (i + 1)));
        }
        // 运行10秒后关闭
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}
class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;
    private final AtomicInteger counter;
    public Producer(BlockingQueue<Integer> queue, AtomicInteger counter) {
        this.queue = queue;
        this.counter = counter;
    }
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                int task = counter.incrementAndGet();
                queue.put(task);  // 如果队列满则阻塞
                System.out.println("生产者生产: " + task + 
                                 ", 队列大小: " + queue.size());
                Thread.sleep((long)(Math.random() * 1000));
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;
    private final String name;
    public Consumer(BlockingQueue<Integer> queue, String name) {
        this.queue = queue;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                Integer task = queue.take();  // 如果队列空则阻塞
                System.out.println(name + " 消费: " + task + 
                                 ", 队列大小: " + queue.size());
                Thread.sleep((long)(Math.random() * 2000));
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

使用 CompletableFuture 实现异步编排

import java.util.concurrent.*;
public class CompletableFutureExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 异步任务编排
        CompletableFuture<String> future = CompletableFuture
            .supplyAsync(() -> {
                System.out.println("任务1执行: " + Thread.currentThread().getName());
                sleep(1000);
                return "Hello";
            }, executor)
            .thenApplyAsync(result -> {
                System.out.println("任务2执行: " + Thread.currentThread().getName());
                sleep(1000);
                return result + " World";
            }, executor)
            .thenApplyAsync(result -> {
                System.out.println("任务3执行: " + Thread.currentThread().getName());
                sleep(500);
                return result + "!";
            }, executor);
        // 等待结果
        System.out.println("最终结果: " + future.get());  // 输出: Hello World!
        // 多个任务组合
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 100);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 200);
        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> 300);
        // 等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);
        allFutures.get();  // 阻塞直到所有完成
        // 合并结果
        CompletableFuture<Integer> combinedFuture = 
            future1.thenCombine(future2, (a, b) -> a + b)
                   .thenCombine(future3, (sum, c) -> sum + c);
        System.out.println("总和: " + combinedFuture.get());  // 输出: 600
        executor.shutdown();
    }
    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

定时任务执行

import java.util.concurrent.*;
public class ScheduledTaskExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
        // 延迟执行
        scheduler.schedule(() -> {
            System.out.println("延迟3秒执行: " + System.currentTimeMillis());
        }, 3, TimeUnit.SECONDS);
        // 定期执行（固定频率）
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("每2秒执行一次: " + Thread.currentThread().getName());
        }, 0, 2, TimeUnit.SECONDS);
        // 定期执行（固定延迟）
        scheduler.scheduleWithFixedDelay(() -> {
            System.out.println("任务完成后延迟1秒再执行: " + System.currentTimeMillis());
            try {
                Thread.sleep(500);  // 模拟任务执行时间
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, 1, 1, TimeUnit.SECONDS);
        // 10秒后关闭
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        scheduler.shutdown();
    }
}

提交任务的常用方法对比

方法 返回值 用途 是否阻塞
execute(Runnable) void 提交无返回值的任务 否
submit(Runnable) Future<?> 提交有返回值的任务 否
submit(Callable<T>) Future 提交有返回值的任务 否
invokeAny(Collection<Callable>) T 提交多个任务，返回第一个完成的结果 是
invokeAll(Collection<Callable>) List<Future> 提交多个任务，等待所有完成 是

这些案例展示了Java中不同的任务提交和执行方式，从简单的Thread到高级的线程池和CompletableFuture,可以根据具体需求选择合适的实现方式。

版权声明：足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播

上一篇Java并发计数器案例如何开发

下一篇Java单线程池案例如何编写

相关文章

抱歉，评论功能暂时关闭!

友情链接攻略窝 · 礼包窝 · 配置窝 · 换算窝 · 算法窝 · 查文窝 · 手册窝 · 问答窝 · 全文搜 · 手册库
相关站点礼包窝 · 查文窝