搜索[AI编程]结果-低调大师优秀个人博客

精选列表

搜索[AI编程]，共10000篇文章

CUDA编程：Histogram 直方图统计与 Atomic 优化

它在图像处理、推荐系统、日志统计、token 分布统计、排序预处理、采样分析中都非常常见。

2026-07-22

Redis 之父：编程已实现自动化

原文：https://antirez.com/news/159 在我的 YouTube 频道里，我已开始用“自动编程”一词指代借助 AI 辅助编写软件的过程

2026-02-03

TIOBE 公布 2025 年度编程语言：C#

TIOBE 是专注于跟踪编程语言流行趋势的网站，近日其宣布 C# 成为 2025 年度编程语言。

2026-01-06

MiniMax 正式开源 M2.1 编程模型

MiniMax近期正式开源了M2.1编程模型，该模型已在Hugging Face、ModelScope和GitHub同步上架。

2025-12-31

Flyde - 可视化后端逻辑编程工具

Flyde是一个用于原型设计、集成、评估和迭代 AI 密集型后端逻辑的整体解决方案。

2025-10-22

蚂蚁集团开源智能编程助手 Neovate Code

蚂蚁集团支付宝体验技术部正式对外开源智能编程助手 Neovate Code，能够深度理解你的代码库，遵循既有编码习惯，并在上下文感知的基础上，精准地完成功能实现、Bug 修复和代码重构。

2025-09-24

编程语言 nature 0.5 发布，首个可用版本

随着 0.5 版本的发布，nature 编程语言最初的设计目标已经完成，语法 API 基本稳定，在 1.0 版本之前不会有大幅的变化。

2025-05-22

使用 Cursor 编程的 15 条经验建议

X 上 1 万+点赞、近百万阅读的爆款帖子—— 《使用 Cursor 编程的 15 条经验建议》 1. 从模板开始：通过从 GitHub 或其他来源克隆模板来开始项目，以提供坚实的基础。

2025-02-28

浅谈 Socket.D 与响应式编程

三、响应式编程，难吗？响应式编程是个老话题了，它早已无处不在，甚至你在Excel里SUM求和，本质上也是种响应式的思维。响应式本质上就是响应变化的数据流。

2023-12-18

并发编程-CompletableFuture解析 | 京东物流技术团队

1、CompletableFuture介绍 CompletableFuture对象是JDK1.8版本新引入的类，这个类实现了两个接口，一个是Future接口，一个是CompletionStage接口。 CompletionStage接口是JDK1.8版本提供的接口，用于异步执行中的阶段处理，CompletionStage定义了一组接口用于在一个阶段执行结束之后，要么继续执行下一个阶段，要么对结果进行转换产生新的结果等，一般来说要执行下一个阶段都需要上一个阶段正常完成，这个类也提供了对异常结果的处理接口 2、CompletableFuture的API 2.1 提交任务在CompletableFuture中提交任务有以下几种方式： public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) public static CompletableFuture supplyAsync(Supplier supplier) public static CompletableFuture supplyAsync(Supplier supplier, Executor executor) 这四个方法都是用来提交任务的，不同的是supplyAsync提交的任务有返回值，runAsync提交的任务没有返回值。两个接口都有一个重载的方法，第二个入参为指定的线程池，如果不指定，则默认使用ForkJoinPool.commonPool()线程池。在使用的过程中尽量根据不同的业务来指定不同的线程池，方便对不同线程池进行监控，同时避免业务共用线程池相互影响。 2.2 结果转换 2.2.1 thenApply public CompletableFuture thenApply(Function<? super T,? extends U> fn) public CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn) public CompletableFuture thenApplyAsync(Function<? super T,? extends U> fn, Executor executor) thenApply这一组函数入参是Function，意思是将上一个CompletableFuture执行结果作为入参，再次进行转换或者计算，重新返回一个新的值。 2.2.2 handle public CompletableFuture handle(BiFunction<? super T, Throwable, ? extends U> fn) public CompletableFuture handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) public CompletableFuture handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor) handle这一组函数入参是BiFunction，该函数式接口有两个入参一个返回值，意思是处理上一个CompletableFuture的处理结果，同时如果有异常，需要手动处理异常。 2.2.3 thenRun public CompletableFuture<Void> thenRun(Runnable action) public CompletableFuture<Void> thenRunAsync(Runnable action) public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) thenRun这一组函数入参是Runnable函数式接口，该接口无需入参和出参，这一组函数是在上一个CompletableFuture任务执行完成后，在执行另外一个接口，不需要上一个任务的结果，也不需要返回值，只需要在上一个任务执行完成后执行即可。 2.2.4 thenAccept public CompletableFuture<Void> thenAccept(Consumer<? super T> action) public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor) thenAccept这一组函数的入参是Consumer，该函数式接口有一个入参，没有返回值，所以这一组接口的意思是处理上一个CompletableFuture的处理结果，但是不返回结果。 2.2.5 thenAcceptBoth public CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action) public CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action) public CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action, Executor executor) thenAcceptBoth这一组函数入参包括CompletionStage以及BiConsumer，CompletionStage是JDK1.8新增的接口，在JDK中只有一个实现类：CompletableFuture，所以第一个入参就是CompletableFuture，这一组函数是用来接受两个CompletableFuture的返回值，并将其组合到一起。BiConsumer这个函数式接口有两个入参，并且没有返回值，BiConsumer的第一个入参就是调用方CompletableFuture的执行结果，第二个入参就是thenAcceptBoth接口入参的CompletableFuture的执行结果。所以这一组函数意思是将两个CompletableFuture执行结果合并到一起。 2.2.6 thenCombine public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor) thenCombine这一组函数和thenAcceptBoth类似，入参都包含一个CompletionStage，也就是CompletableFuture对象，意思也是组合两个CompletableFuture的执行结果，不同的是thenCombine的第二个入参为BiFunction，该函数式接口有两个入参，同时有一个返回值。所以与thenAcceptBoth不同的是，thenCombine将两个任务结果合并后会返回一个全新的值作为出参。 2.2.7 thenCompose public CompletableFuture thenCompose(Function<? super T, ? extends CompletionStage> fn) public CompletableFuture thenComposeAsync(Function<? super T, ? extends CompletionStage> fn) public CompletableFuture thenComposeAsync(Function<? super T, ? extends CompletionStage> fn, Executor executor) thenCompose这一组函数意思是将调用方的执行结果作为Function函数的入参，同时返回一个新的CompletableFuture对象。 2.3 回调方法 public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor) whenComplete方法意思是当上一个CompletableFuture对象任务执行完成后执行该方法。BiConsumer函数式接口有两个入参没有返回值，这两个入参第一个是CompletableFuture任务的执行结果，第二个是异常信息。表示处理上一个任务的结果，如果有异常，则需要手动处理异常，与handle方法的区别在于，handle方法的BiFunction是有返回值的，而BiConsumer是没有返回值的。以上方法都有一个带有Async的方法，带有Async的方法表示是异步执行的，会将该任务放到线程池中执行，同时该方法会有一个重载的方法，最后一个参数为Executor，表示异步执行可以指定线程池执行。为了方便进行控制，最好在使用CompletableFuture时手动指定我们的线程池。 2.4 异常处理 public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) exceptionally是用来处理异常的，当任务抛出异常后，可以通过exceptionally来进行处理，也可以选择使用handle来进行处理，不过两者有些不同，hand是用来处理上一个任务的结果，如果有异常情况，就处理异常。而exceptionally可以放在CompletableFuture处理的最后，作为兜底逻辑来处理未知异常。 2.5 获取结果 public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) allOf是需要入参中所有的CompletableFuture任务执行完成，才会进行下一步； anyOf是入参中任何一个CompletableFuture任务执行完成都可以执行下一步。 public T get() throws InterruptedException, ExecutionException public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException public T getNow(T valueIfAbsent) public T join() get方法一个是不带超时时间的，一个是带有超时时间的。 getNow方法则是立即返回结果，如果还没有结果，则返回默认值，也就是该方法的入参。 join方法是不带超时时间的等待任务完成。 3、CompletableFuture原理 join方法同样表示获取结果，但是join与get方法有什么区别呢。 public T join() { Object r; return reportJoin((r = result) == null ? waitingGet(false) : r); } public T get() throws InterruptedException, ExecutionException { Object r; return reportGet((r = result) == null ? waitingGet(true) : r); } public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { Object r; long nanos = unit.toNanos(timeout); return reportGet((r = result) == null ? timedGet(nanos) : r); } public T getNow(T valueIfAbsent) { Object r; return ((r = result) == null) ? valueIfAbsent : reportJoin(r); } 以上是CompletableFuture类中两个方法的代码，可以看到两个方法几乎一样。区别在于reportJoin/reportGet，waitingGet方法是一致的，只不过参数不一样，我们在看下reportGet与reportJoin方法。 private static <T> T reportGet(Object r) throws InterruptedException, ExecutionException { if (r == null) // by convention below, null means interrupted throw new InterruptedException(); if (r instanceof AltResult) { Throwable x, cause; if ((x = ((AltResult)r).ex) == null) return null; if (x instanceof CancellationException) throw (CancellationException)x; if ((x instanceof CompletionException) && (cause = x.getCause()) != null) x = cause; throw new ExecutionException(x); } @SuppressWarnings("unchecked") T t = (T) r; return t; } private static <T> T reportJoin(Object r) { if (r instanceof AltResult) { Throwable x; if ((x = ((AltResult)r).ex) == null) return null; if (x instanceof CancellationException) throw (CancellationException)x; if (x instanceof CompletionException) throw (CompletionException)x; throw new CompletionException(x); } @SuppressWarnings("unchecked") T t = (T) r; return t; } 可以看到这两个方法很相近，reportGet方法判断了r对象是否为空，并抛出了中断异常，而reportJoin方法没有判断，同时reportJoin抛出的都是运行时异常，所以join方法也是无需手动捕获异常的。我们在看下waitingGet方法 private Object waitingGet(boolean interruptible) { Signaller q = null; boolean queued = false; int spins = -1; Object r; while ((r = result) == null) { if (spins < 0) spins = SPINS; else if (spins > 0) { if (ThreadLocalRandom.nextSecondarySeed() >= 0) --spins; } else if (q == null) q = new Signaller(interruptible, 0L, 0L); else if (!queued) queued = tryPushStack(q); else if (interruptible && q.interruptControl < 0) { q.thread = null; cleanStack(); return null; } else if (q.thread != null && result == null) { try { ForkJoinPool.managedBlock(q); } catch (InterruptedException ie) { q.interruptControl = -1; } } } if (q != null) { q.thread = null; if (q.interruptControl < 0) { if (interruptible) r = null; // report interruption else Thread.currentThread().interrupt(); } } postComplete(); return r; } 该waitingGet方法是通过while的方式循环判断是否任务已经完成并产生结果，如果结果为空，则会一直在这里循环，这里需要注意的是在这里初始化了一下spins=-1，当第一次进入while循环的时候，spins是-1，这时会将spins赋值为一个常量，该常量为SPINS。 private static final int SPINS = (Runtime.getRuntime().availableProcessors() > 1 ? 1 << 8 : 0); 这里判断可用CPU数是否大于1，如果大于1，则该常量为 1<< 8，也就是256，否则该常量为0。第二次进入while循环的时候，spins是256大于0，这里做了减一的操作，下次进入while循环，如果还没有结果，依然是大于0继续做减一的操作，此处用来做短时间的自旋等待结果，只有当spins等于0，后续会进入正常流程判断。我们在看下timedGet方法的源码 private Object timedGet(long nanos) throws TimeoutException { if (Thread.interrupted()) return null; if (nanos <= 0L) throw new TimeoutException(); long d = System.nanoTime() + nanos; Signaller q = new Signaller(true, nanos, d == 0L ? 1L : d); // avoid 0 boolean queued = false; Object r; // We intentionally don't spin here (as waitingGet does) because // the call to nanoTime() above acts much like a spin. while ((r = result) == null) { if (!queued) queued = tryPushStack(q); else if (q.interruptControl < 0 || q.nanos <= 0L) { q.thread = null; cleanStack(); if (q.interruptControl < 0) return null; throw new TimeoutException(); } else if (q.thread != null && result == null) { try { ForkJoinPool.managedBlock(q); } catch (InterruptedException ie) { q.interruptControl = -1; } } } if (q.interruptControl < 0) r = null; q.thread = null; postComplete(); return r; } timedGet方法依然是通过while循环的方式来判断是否已经完成，timedGet方法入参为一个纳秒值，并通过该值计算出一个deadline截止时间，当while循环还未获取到任务结果且已经达到截止时间，则抛出一个TimeoutException异常。 4、CompletableFuture实现多线程任务这里我们通过CompletableFuture来实现一个多线程处理异步任务的例子。这里我们创建10个任务提交到我们指定的线程池中执行，并等待这10个任务全部执行完毕。每个任务的执行流程为第一次先执行加法，第二次执行乘法，如果发生异常则返回默认值，当10个任务执行完成后依次打印每个任务的结果。 public void demo() throws InterruptedException, ExecutionException, TimeoutException { // 1、自定义线程池 ExecutorService executorService = new ThreadPoolExecutor(5, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(100)); // 2、集合保存future对象 List<CompletableFuture<Integer>> futures = new ArrayList<>(10); for (int i = 0; i < 10; i++) { int finalI = i; CompletableFuture<Integer> future = CompletableFuture // 提交任务到指定线程池 .supplyAsync(() -> this.addValue(finalI), executorService) // 第一个任务执行结果在此处进行处理 .thenApplyAsync(k -> this.plusValue(finalI, k), executorService) // 任务执行异常时处理异常并返回默认值 .exceptionally(e -> this.defaultValue(finalI, e)); // future对象添加到集合中 futures.add(future); } // 3、等待所有任务执行完成，此处最好加超时时间 CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(5, TimeUnit.MINUTES); for (CompletableFuture<Integer> future : futures) { Integer num = future.get(); System.out.println("任务执行结果为：" + num); } System.out.println("任务全部执行完成！"); } private Integer addValue(Integer index) { System.out.println("第" + index + "个任务第一次执行"); if (index == 3) { int value = index / 0; } return index + 3; } private Integer plusValue(Integer index, Integer num) { System.out.println("第" + index + "个任务第二次执行，上次执行结果：" + num); return num * 10; } private Integer defaultValue(Integer index, Throwable e) { System.out.println("第" + index + "个任务执行异常！" + e.getMessage()); e.printStackTrace(); return 10; } 作者：京东物流丁冬来源：京东云开发者社区自猿其说Tech

2023-07-28

并发编程-FutureTask解析 | 京东物流技术团队

1、FutureTask对象介绍 Future对象大家都不陌生，是JDK1.5提供的接口，是用来以阻塞的方式获取线程异步执行完的结果。在Java中想要通过线程执行一个任务，离不开Runnable与Callable这两个接口。 Runnable与Callable的区别在于，Runnable接口只有一个run方法，该方法用来执行逻辑，但是并没有返回值；而Callable的call方法，同样用来执行业务逻辑，但是是有一个返回值的。 Callable执行任务过程中可以通过FutureTask获得任务的执行状态，并且可以在执行完成后通过Future.get()方式获取执行结果。 Future是一个接口，而FutureTask就是Future的实现类。并且FutureTask实现了 RunnableFuture（Runnable + Future），说明我们可以创建一个FutureTask并直接把它放到线程池执行，然后获取FutureTask的执行结果。 2、FutureTask源码解析 2.1 主要方法和属性那么FutureTask是如何通过阻塞的方式来获取到异步线程执行的结果的呢？我们看下FutureTask中的属性。 // FutureTask的状态及其常量 private volatile int state; private static final int NEW = 0; private static final int COMPLETING = 1; private static final int NORMAL = 2; private static final int EXCEPTIONAL = 3; private static final int CANCELLED = 4; private static final int INTERRUPTING = 5; private static final int INTERRUPTED = 6; // callable对象，执行完后置空 private Callable<V> callable; // 要返回的结果或要引发的异常来自 get() 方法 private Object outcome; // non-volatile, protected by state reads/writes // 执行Callable的线程 private volatile Thread runner; // 等待线程的一个链表结构 private volatile WaitNode waiters; FutureTask中几个比较重要的方法。 // 取消任务的执行 boolean cancel(boolean mayInterruptIfRunning); // 返回任务是否已经被取消 boolean isCancelled(); // 返回任务是否已经完成，任务状态不为NEW即为完成 boolean isDone(); // 通过get方法获取任务的执行结果 V get() throws InterruptedException, ExecutionException; // 通过get方法获取任务的执行结果，带有超时，如果超过给定时间则抛出异常 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; 2.2 FutureTask执行当我们在线程池中执行一个Callable方法时，其实是将Callable任务封装成一个RunnableFuture对象去执行，同时将这个RunnableFuture对象返回，这样我们就拿到了FutureTask的引用，可以随时获取到任务执行的状态，并且可以在任务执行完成后通过该对象获取执行结果。以下为ThreadPoolExecutor线程池提交一个callable方法的源码。 public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); execute(ftask); return ftask; } protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { return new FutureTask<T>(callable); } 2.3 run方法介绍 RunnableFuture其实也是一个可以执行的runnable，我们看下他的run方法。其主要流程就是执行call方法，正常执行完毕后将result结果赋值到outcome属性上。 public void run() { if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { // 将callable赋值到本地变量 Callable<V> c = callable; // 判断callable不为空并且FutureTask的状态必须为新创建 if (c != null && state == NEW) { V result; boolean ran; try { // 执行call方法（用户自己实现的call逻辑），并获取到result结果 result = c.call(); ran = true; } catch (Throwable ex) { result = null; ran = false; // 如果执行过程出现异常，则将异常对象赋值到outcome上 setException(ex); } // 如果正常执行完毕，则将result赋值到outcome属性上 if (ran) set(result); } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() runner = null; // state must be re-read after nulling runner to prevent // leaked interrupts int s = state; if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } } 以下逻辑为正常执行完成后赋值的逻辑。 // 如果任务没有被取消，将future执行完的返回值赋值给result结果 // FutureTask任务的执行状态是通过CAS的方式进行赋值的，并且由此可知，COMPLETING其实是一个瞬时状态 // 当将线程执行结果赋值给outcome后，状态会修改为对应的NORMAL，即正常结束 protected void set(V v) { if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = v; UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state finishCompletion(); } } 以下为执行异常时赋值逻辑，直接将Throwable对象赋值到outcome属性上。 protected void setException(Throwable t) { if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = t; UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state finishCompletion(); } } 无论是正常执行还是异常执行，最终都会调用一个finishCompletion方法，用来做工作的收尾工作。 2.4 get方法介绍 Future的get方法有两个重载的方法，一个是get()获取结果，一个是get(long, TimeUnit)带有超时时间的获取结果，我们看下FutureTask中的这两个方法是如何实现的。 // 不带有超时时间，一直阻塞直到获取结果 public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= COMPLETING) // 等待结果完成，带有超时的get方法也是调用的awaitDone方法 s = awaitDone(false, 0L); // 返回结果 return report(s); } // 带有超时时间的获取结果，如果超过时间还没有获取到结果则抛出异常 public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { if (unit == null) throw new NullPointerException(); int s = state; // 如果任务未中断，调用awaitDone方法等待任务结果 if (s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) throw new TimeoutException(); // 返回结果 return report(s); } 我们主要看下awaitDone方法的执行逻辑。此方法会通过for循环的方式一直阻塞等待任务执行完成。如果带有超时时间，则超过截止时间后会直接返回。 // timed：是否需要超时获取 // nanos：超时时间单位纳秒 private int awaitDone(boolean timed, long nanos) throws InterruptedException { final long deadline = timed ? System.nanoTime() + nanos : 0L; WaitNode q = null; boolean queued = false; // 此方法会一直for循环判断任务状态是否已经完成，是Future.get阻塞的原因 for (;;) { if (Thread.interrupted()) { removeWaiter(q); throw new InterruptedException(); } int s = state; // 任务状态大于COMPLETING，则表明任务结束，直接返回 if (s > COMPLETING) { if (q != null) q.thread = null; return s; } else if (s == COMPLETING) // cannot time out yet // Thread.yield() 方法，使当前线程由执行状态，变成为就绪状态，让出cpu时间，在下一个线程执行时候，此线程有可能被执行，也有可能没有被执行。 // COMPLETING状态为瞬时状态，任务执行完成，要么是正常结束，要么异常结束，后续会被置为NORMAL或者EXCEPTIONAL Thread.yield(); else if (q == null) // 每调用一次get方法，都会创建一个WaitNode等待节点 q = new WaitNode(); else if (!queued) // 将该等待节点添加到链表结构waiters中，q.next = waiters 即在waiters的头部插入 queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q); // 如果方法带有超时判断，则判断当前时间是否已经超过了截止时间，如果超过了及截止日期，则退出循环直接返回当前状态，此时任务状态一定是NEW else if (timed) { nanos = deadline - System.nanoTime(); if (nanos <= 0L) { removeWaiter(q); return state; } LockSupport.parkNanos(this, nanos); } else LockSupport.park(this); } } 我们在看下report方法，在调用get方法时是如何返回结果的。这里首先获取outcome的值，并判断任务是否已经执行完成，如果执行完成，则将outcome对象强转成泛型指定的类型；如果任务被取消了，则抛出一个CancellationException异常；如果都不是，则说明任务在执行过程中发生了异常，此时任务状态位EXCEPTIONAL，此时的outcome即为Throwable对象，所以将outcome强转为Throwable并抛出异常。由此可以知道，我们将一个FutureTask任务submit到线程池中执行的时候，如果发生了异常，是会在调用get方法的时候抛出的。 private V report(int s) throws ExecutionException { Object x = outcome; if (s == NORMAL) return (V)x; if (s >= CANCELLED) throw new CancellationException(); throw new ExecutionException((Throwable)x); } 2.5 cancel方法介绍 cancel方法用于取消正在运行的任务，如果任务取消成功，则返回TRUE，如果取消失败则返回FALSE。 // mayInterruptIfRunning：允许中断正在运行的任务 public boolean cancel(boolean mayInterruptIfRunning) { // mayInterruptIfRunning如果为true则将状态置为INTERRUPTING，如果未false则将状态置为CANCELLED if (!(state == NEW && UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED))) return false; // 如果状态修改成功后，判断是否允许中断线程，如果允许，则调用Thread的interrupt方法中断 try { // in case call to interrupt throws exception if (mayInterruptIfRunning) { try { Thread t = runner; if (t != null) t.interrupt(); } finally { // final state UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); } } } finally { // 取消后的收尾工作 finishCompletion(); } return true; } 2.6 isDone/isCancelled方法介绍 isDone方法用于判断FutureTask是否已经完成；isCancelled方法用来判断FutureTask是否已经取消，这两个方法都是通过状态位来判断的。 public boolean isCancelled() { return state >= CANCELLED; } public boolean isDone() { return state != NEW; } 2.7 finishCompletion方法介绍我们看下finishCompletion方法都做了哪些工作。 // 删除所有等待线程并发出信号，最后执行done方法 private void finishCompletion() { // assert state > COMPLETING; for (WaitNode q; (q = waiters) != null;) { if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { for (;;) { Thread t = q.thread; if (t != null) { q.thread = null; LockSupport.unpark(t); } WaitNode next = q.next; if (next == null) break; q.next = null; // unlink to help gc q = next; } break; } } done(); callable = null; // to reduce footprint } 我们看到done方法是一个受保护的空方法，此处没有任何逻辑，由其子类去根据自己的业务去实现相应的逻辑。例如：java.util.concurrent.ExecutorCompletionService.QueueingFuture。 protected void done() { } 3、总结通过源码解读可以了解到Future的原理：第一步：主线程将任务封装成一个Callable对象，通过submit方法提交到线程池去执行。第二步：线程池执行任务的run方法，主线程则可以继续执行其他逻辑。第三步：线程池中方法执行完成后将结果赋值到outcome属性上，并修改任务状态。第四步：主线程在需要拿到异步任务结果的时候，主动调用fugure.get()方法来获取结果。第五步：如果异步线程在执行过程中发生异常，则会在调用future.get()方法的时候抛出来。以上就是对于FutureTask的分析，我们可以了解FutureTask任务执行的方式以及Future.get已阻塞的方式获取线程执行的结果原理，并且从代码中可以了解FutureTask的任务执行状态以及状态的变化过程。作者：京东物流丁冬来源：京东云开发者社区自猿其说Tech

2023-07-27

未来的编程语言「GitHub 热点速览」

又一个编程语言火了，不算新，因为它已经开发了一段时间。不过在本周 Hacker News 上风头十足，DreamBerd 除了有点意思的改 ; 分隔符为 !

2023-06-26

实例讲解Flink 流处理程序编程模型

本文分享自华为云社区《Flink 实例：Flink 流处理程序编程模型》，作者：TiAmoZhang 。

2023-06-09

Haxe 4.3 发布，高级严格类型编程语言

Haxe 是开源的高级严格类型编程语言，具有快速且经过优化的交叉编译器。

2023-04-09

JAVA多线程并发编程-避坑指南

因此无论使用什么线程池，使用完毕后均调用 shutdown 是一个较为安全的编程习惯。 4、线程池处理“刚启动时效率低” 默认情况下，即使是核心线程也只能在新任务到达时才创建和启动。

2023-04-04

Rust-GPU —— 面向 GPU 编程的 Rust

Rust-GPU 是面向 GPU 编程的开源项目，目标是使 Rust 成为 GPU 着色器开发的“一等公民”编程语言和生态系统。

2023-01-07

扔掉键盘，GitHub Copilot 已支持语音编程

我们已经介绍和报道过很多次 GitHub Copilot 的相关资讯了，它就是一项利用 AI 帮助开发者编写代码的服务，Copilot 可以在开发者使用 Visual Studio、VS Code、Neovim

2022-11-11

深度 deepin 开源自研编程语言：Unilang

deepin 宣布了自研的全新通用目的编程语言：Unilang，其仓库提供了文档和作为参考实现的解释器。

2022-09-18

TIOBE 编程语言排行榜被“喷”

程序员社区知名“月经贴”——TIOBE 编程语言排行榜被“喷”了。最近开发者 Krishna发文指出 TIOBE 编程语言排行榜的诸多不合理之处，并建议大家不要再引用它。

2022-08-08

Melody Lang —— 面向 JS 的新兴编程语言

Melody 是一种可将代码编译为 ECMAScript 正则表达式的语言，旨在更易于阅读和维护。例子注意：这些是当前支持的语法，可能会改变 Batman Theme 16 of "na"; 2 of match { <space>; "batman"; } // 🦇🦸 ♂️ 转变成 (?:na){16}(?: batman){2} Twitter Hashtag "#"; some of <word>; // #melody 转变成 #\\w+ Introductory Courses some of <alphabetic>; <space>; "1"; 2 of <digit>; // classname 1xx 转变成 [a-zA-Z]+ 1\\d{2} Indented Code (2 spaces) some of match { 2 of <space>; } some of <char>; ";"; // let value = 5; 转变成 (?: {2})+.+; 安装 Cargo cargo install melody_cli 从源代码 git clone https://github.com/yoav-lavi/melody.git cd melody cargo install --path crates/melody_cli Binary macOS binaries (aarch64 and x86_64) 可从 release 页面下载

2022-05-30

资源下载

更多资源

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。