【异步】Futurn、FutureTask、CompletionService、CompletableFuture

news2025/1/12 0:47:27

1. Callable

在这篇文章中 【Thread】线程的基本概念及创建方式（一），我们知道创建线程的几种方式。其中，有两个是通过接口来实现的：Runnable、Callable。它们的区别如下：

  • Runnable 接口中的方法是没有返回值的，而 Callable 接口中的方法是有返回值的
  • Callable 接口中的方法是可以抛异常的

如何使用 Callable 接口

有两种方式可以使用 Callable 接口：

  1. 通过 Thread，再结合 Future 、FutureTask
  2. 通过线程池的 submit()、invokeAll()、invokeAny() 方法

方式一：

public static void main(String[] args) throws Exception {
    Callable<String> task = () -> "I am a callable Task";
    // 将 Callable 封装为 FutureTask
    FutureTask<String> futureTask = new FutureTask<>(task);
    new Thread(futureTask).start();
    String result = futureTask.get();
}

注意：get() 方法是一个阻塞方法，没有获取到结果之前，一直处于阻塞状态！

方式二：

public static void main(String[] args) throws Exception {
    Callable<String> task = () -> "I am a callable Task";
    ExecutorService threadPool = Executors.newFixedThreadPool(2);
    Future<String> future = threadPool.submit(task);
    String result = future.get();
    threadPool.shutdown();
}

2. Future 、FutureTask

首先，看看它们之间的关系图，如下：

在这里插入图片描述

Future 接口： Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get() 方法获取执行结果，该方法会阻塞直到任务返回结果

public interface Future<V> {
    // 取消任务，如果任务正在运行的，mayInterruptIfRunning为true时，表明这个任务会被打断的，并返回true；
    // 为false时，会等待这个任务执行完，返回true；若任务还没执行，取消任务后返回true，如任务执行完，返回false
    boolean cancel(boolean mayInterruptIfRunning);
    // 判断任务是否被取消了,正常执行完不算被取消
    boolean isCancelled();
    // 判断任务是否已经执行完成，任务取消或发生异常也算是完成，返回true
    boolean isDone();
    // 获取任务返回结果，如果任务没有执行完成则等待完成将结果返回，如果获取的过程中发生异常就抛出异常，
    // 比如中断就会抛出InterruptedException异常等异常
    V get() throws InterruptedException, ExecutionException;
    // 在规定的时间如果没有返回结果就会抛出TimeoutException异常
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

FutureTask 接口：FutureTask 实现了 RunnableFuture 接口，而此接口又继承了 Runnable 接口、Future 接口。所以，必然会重新 run() 方法、Future 接口中的方法

public class FutureTask<V> implements RunnableFuture<V> {

	private Callable<V> callable;
	// 存储任务结果
	private Object outcome;
	
	public void run() {
        if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result = c.call();
                set(result);
            }
        } finally {
            //...
        }
    }
    
    protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        	// 将结果赋值给 outcome
            outcome = v;
            // 修改线程状态
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
            // 移除所有等待线程并发出信号
            finishCompletion();
        }
    }
    
    private void finishCompletion() {
        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
    }
}

FutureTask.run() 方法的逻辑是：通过调用 Callable.call() 方法去执行任务，并将返回的结果通过 set() 方法赋值给 outcome 属性。

那么，上述的代码块：new Thread(futureTask).start();的流程是：

通过 Thread 的 start() 方法执行了 FutureTask 的 run() 方法，最终通过 Callable 的 call() 方法执行了！

get() 方法的实现： get() 方法里会先通过 state 变量判断任务是否已跑完：若跑完，则直接将结果返回；否则，就构造等待节点，并扔进等待队列自旋，阻塞主线程。另一边的线程计算出结果后就会将等待队列里的所有节点依次出队并唤醒线程

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    // 任务还未执行完，等待执行完
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    // 任务执行完|已取消，返回结果或者抛出异常
    return report(s);
}

private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
    	// 发生线程中断，从等待队列中移除节点，并抛出中断异常
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        // 任务已执行完|已取消
        if (s > COMPLETING) {
        	// 若已有等待节点，将线程置空，避免另外一边再次调用 unpark()
            if (q != null)
                q.thread = null;
            return s;
        }
        // 任务正在执行，让出时间片
        else if (s == COMPLETING)
            Thread.yield();
        // 如果还未构造等待队列节点，则构造
        else if (q == null)
            q = new WaitNode();
        // 如果为入队，则 CAS 尝试入队；如果入队失败，则下一次循环再次尝试
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        // 通过 LockSupport.park() 阻塞线程
        else if (timed) {
            nanos = deadline - System.nanoTime();
            // 如果限时，且不大于 0，则从等待队列中移除节点，并返回
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            LockSupport.park(this);
    }
}

private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)
        return (V)x;
    //...
}

get() 方法处理逻辑如下：

  1. 先判断 state 的值是否大于 comleting，也就是执行完，是的话就判断 state 为 normal 正常的话，就返回 outcome 结果，为 cancel 取消的话，就抛取消异常，为异常的话，就抛出 outcome 记录的异常
  2. 如果 state 的值表示还没执行完的话，就会进入一个自旋操作，也就是一个死循环
  3. 如果 state 是 completing 的话，就通过 Thread.yield 让出时间片
  4. 否则如果结果已经出来了，那就返回
  5. 否则如果还未构造等待结点，那就构造等待结点，结点里保存了当前线程
  6. 否则如果结点还未入队，那就将结点入队
  7. 否则调用 LockSupport.park() 方法阻塞线程

执行任务的线程那边在执行完任务后(执行完 run() 方法)，就把结果或者异常保存到 outcome 里，修改 state 的值，并且依次将队列里的结点出队，并调用 LockSupport.unpark() 方法唤醒节点里的线程（这些操作是在 set() 方法中）

案例：使用 Future 来批量执行多个异步任务的业务并获取结果

ExecutorService executor = Executors.newFixedThreadPool(2); 
Future f1 = excutor.submit(c1);
f1.get();
Future f2 = excutor.submit(c2);
f2.get();

f1.get() 在获取成功之前会被阻塞，会阻塞 c2 的执行，严重降低了效率

Future 接口局限性：

从本质上说，Future 表示一个异步计算的结果。它提供了 isDone() 来检测计算是否已经完成，并且在计算结束后，可以通过get() 方法来获取计算结果。但它本身也确实存在着许多限制：

  1. 并发执行多任务：Future 只提供了 get() 方法来获取结果，并且是阻塞的
  2. 无法对多个任务进行链式调用：如果你希望在计算任务完成后执行特定动作，比如发邮件，但 Future 却没有提供这样的能力
  3. 无法组合多个任务：如果你运行了10个任务，并期望在它们全部执行结束后执行特定动作，那么在 Future 中这是无能为力的
  4. 没有异常处理：Future 接口中没有关于异常处理的方法

3. CompletionService

Callable + Future 虽然可以实现多个 task 并行执行，但是如果遇到前面的 task 执行较慢时需要阻塞等待前面的 task 执行完后面 task 才能取得结果。而 CompletionService 的主要功能就是：一边生成任务,一边获取任务的返回值。让两件事分开执行,任务之间不会互相阻塞，可以实现先执行完的先取结果，不再依赖任务顺序了

ExecutorCompletionService 类实现了 CompletionService 接口

使用 CompletionService 来优化上述的案例

public static void main(String[] args) throws InterruptedException, ExecutionException {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);

    Future<Integer> f1 = cs.submit(() -> {
        Thread.sleep(2000);
        return 1;
    });
    Future<Integer> f2 = cs.submit(() -> {
        Thread.sleep(1000);
        return 2;
    });
    for (int i = 0; i < 2; i++) {
        Integer integer = cs.take().get();
        System.out.println(integer);
    }
}

CompletionService 接口：

public class ExecutorCompletionService<V> implements CompletionService<V> {
	private final Executor executor;
    private final AbstractExecutorService aes;
    // 已完成的任务队列
    private final BlockingQueue<Future<V>> completionQueue;
	
	public Future<V> submit(Callable<V> task) {
		// 将 Callable 转化为 FutureTask
        RunnableFuture<V> f = newTaskFor(task);
        // 会调用 FutureTask 类中的 run() 方法
        executor.execute(new QueueingFuture(f));
        return f;
    }
	
	// 将 Callable 转化为 FutureTask
	private RunnableFuture<V> newTaskFor(Callable<V> task) {
        if (aes == null)
            return new FutureTask<V>(task);
        else
            return aes.newTaskFor(task);
    }
	
	// 内部类：任务完成后，将已完成的任务添加到队列中
	private class QueueingFuture extends FutureTask<Void> {
        QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
        // done() 方法：FutureTask 中的 finishCompletion() 方法调用。这里，被子类重写
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;
    }
}

再来看看 take() 或者 poll()：都是操作 completionQueue

public Future<V> take() throws InterruptedException {
    return completionQueue.take();
}

public Future<V> poll() {
    return completionQueue.poll();
}

public Future<V> poll(long timeout, TimeUnit unit)
        throws InterruptedException {
    return completionQueue.poll(timeout, unit);
}

4. CompletionStage

CompletionStage 是 Java 8 新增的接口，用于：异步执行中的阶段处理

场景：一个大的任务可以拆分成多个子任务，并且子任务之间有明显的先后顺序或者一个子任务依赖另一个子任务完成的结果时，那么 CompletionStage 是一个不错的选择

CompletionStage 就是实现了将一个大任务分成若个子任务，这些子任务基于一定的并行、串行组合形成任务的不同阶段

查看其接口：

public interface CompletionStage<T> {

	public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);
	//...
	public CompletionStage<Void> runAfterBoth(CompletionStage<?> other, Runnable action);
	//...
	public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn);
	//...
}

CompletionStage 接口中方法很多，但不难发现有规律可循：基本都是由 then、apply、async、accept、run、combine、both、either、after、compose、when、handle 等关键词组合而成。这些关键字可以理解如下：

  • then：表示阶段先后顺序，即一个阶段等待另一个阶段完成
  • apply：和 Function 一样，表示消费一个参数并提供一个结果
  • async：异步标志，即阶段任务的执行相对于当前线程是同步还是异步
  • accept：和 Consumer 一样，表示消费一个参数
  • run：既不消费也不铲除，同 Runnable 接口含义
  • combine：合并两个阶段结果并返回新的阶段
  • both：表示二者条件都成立再做其它事
  • either：表示二者之一条件成立再做其它事，对应 both
  • after:表先后顺序，一个任务发生在另一个任务之后，和 then 相似
  • compose：表示根据已有结果生成新的结果，同 Function，细看 compose 的参数和 thenApply 有区别，具体区别再下面陈述
  • when：等同于 whenComplete，当前阶段正常完成或异常完成时执行 BiConsumer 动作
  • handle：当前阶段正常完成或异常完成后触发一个 BiFunction 动作

5. CompletableFuture

CompletableFuture 实现了 Future 接口，并在此基础上进行了丰富的扩展，完美弥补了 Future 的局限性，同时CompletableFuture 实现了 CompletionStage 接口，对任务编排的能力

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
	// 存储结果
	volatile Object result;
}

5.1 常用方法


依赖关系

  • thenApply()：把前面任务的执行结果，交给后面的 Function
CompletableFuture.supplyAsync(() -> 100).thenApply(x -> x * 100);
  • thenCompose()：用来连接两个有依赖关系的任务，结果由第二个任务返回
CompletableFuture.supplyAsync(() -> 100).thenCompose(x -> CompletableFuture.supplyAsync(() -> x * 100));

and 集合关系

  • thenCombine()：合并任务，有返回值
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 100);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 200);
Integer result = future1.thenCombine(future2, Integer::sum).get();
  • thenAccepetBoth()：两个任务执行完成后，将结果交给 thenAccepetBoth 处理，无返回值
future1.thenAcceptBoth(future2, (x, y) -> System.out.println(x + y));
  • runAfterBoth()：两个任务都执行完成后，执行下一步操作（Runnable 类型任务）。都是 同步执行
future1.runAfterBoth(future2, () -> System.out.println(Thread.currentThread().getName()));

or 聚合关系

  • applyToEither()：两个任务哪个执行的快，就使用哪一个结果，有返回值
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);
    return 100;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(500);
    return 200;
});
System.out.println(future1.applyToEither(future2, x -> x * 100).get());
  • acceptEither()：两个任务哪个执行的快，就消费哪一个结果，无返回值
  • runAfterEither()：任意一个任务执行完成，进行下一步操作（Runnable 类型任务）

并行执行

  • allOf()：当所有给定的 CompletableFuture 完成时，返回一个新的 CompletableFuture
  • anyOf()：当任何一个给定的CompletablFuture完成时，返回一个新的CompletableFuture

异步操作

  • runAsync()：
  • supplyAsync()：

使用没有指定 Executor 的方法时，内部使用 ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。
默认情况下 CompletableFuture 会使用公共的 ForkJoinPool 线程池，这个线程池默认创建的线程数是 CPU 的核数（也可以通过 JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism 来设置 ForkJoinPool 线程池的线程数）。如果所有 CompletableFuture 共享一个线程池，那么一旦有任务执行一些很慢的 I/O 操作，就会导致线程池中所有线程都阻塞在 I/O 操作上，从而造成线程饥饿，进而影响整个系统的性能。所以，强烈建议你要根据不同的业务类型创建不同的线程池，以避免互相干扰

获取结果

  • get()：
  • join()：

方法总结：

在这里插入图片描述

5.2 场景

著名数学家华罗庚先生在《统筹方法》这篇文章里介绍了一个烧水泡茶的例子，文中提到最优的工序应该是下面这样：
在这里插入图片描述
对于烧水泡茶这个程序，一种最优的分工方案：用两个线程 T1 和 T2 来完成烧水泡茶程序，T1 负责洗水壶、烧开水、泡茶这三道工序，T2 负责洗茶壶、洗茶杯、拿茶叶三道工序，其中 T1 在执行泡茶这道工序时需要等待 T2 完成拿茶叶的工序

基于 Future 的实现

public class T2 implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("T2:洗茶壶...");
        TimeUnit.SECONDS.sleep(1);

        System.out.println("T2:洗茶杯...");
        TimeUnit.SECONDS.sleep(2);

        System.out.println("T2:拿茶叶...");
        TimeUnit.SECONDS.sleep(1);
        return "龙井";
    }
    
}

public class T1 implements Callable<String> {

    private FutureTask<String> t2;

    public T1(FutureTask<String> t2) {
        this.t2 = t2;
    }

    @Override
    public String call() throws Exception {
        System.out.println("T1:洗水壶...");
        TimeUnit.SECONDS.sleep(1);

        System.out.println("T1:烧开水...");
        TimeUnit.SECONDS.sleep(15);

        // 获取 T2 的茶叶
        String chaYe = t2.get();
        System.out.println("T1:拿到茶叶:" + chaYe);
        System.out.println("T1:泡茶...");
        return "上茶:" + chaYe;
    }

}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    FutureTask<String> task2 = new FutureTask<>(new T2());
    FutureTask<String> task1 = new FutureTask<>(new T1(task2));

    new Thread(task1).start();
    new Thread(task2).start();
    System.out.println(task1.get());
}

基于 CompletableFuture 的实现

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //任务1：洗水壶->烧开水
    CompletableFuture<Void> task1 = CompletableFuture.runAsync(() -> {
        System.out.println("T1:洗水壶...");
        sleep(1, TimeUnit.SECONDS);

        System.out.println("T1:烧开水...");
        sleep(15, TimeUnit.SECONDS);
    });
    //任务2：洗茶壶->洗茶杯->拿茶叶
    CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
        System.out.println("T2:洗茶壶...");
        sleep(1, TimeUnit.SECONDS);

        System.out.println("T2:洗茶杯...");
        sleep(2, TimeUnit.SECONDS);

        System.out.println("T2:拿茶叶...");
        sleep(1, TimeUnit.SECONDS);
        return "龙井";
    });
    //任务3：任务1和任务2完成后执行：泡茶
    CompletableFuture<String> f3 = task1.thenCombine(task2, (x, y) -> {
        System.out.println("T1:拿到茶叶:" + y);
        System.out.println("T1:泡茶...");
        return "上茶:" + y;
    });
    //等待任务3执行结果
    System.out.println(f3.join());
}

static void sleep(int t, TimeUnit u) {
    try {
        u.sleep(t);
    } catch (InterruptedException e) {
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/655457.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

代码审计——XXE详解

代码审计——XXE详解

为方便您的阅读&#xff0c;可点击下方蓝色字体&#xff0c;进行跳转↓↓↓ 01 漏洞描述02 审计要点03 漏洞特征04 漏洞案例05 修复方案 01 漏洞描述 XXE&#xff08;XML External Entity Injection&#xff09;是一种针对XML终端实施的攻击&#xff0c;漏洞产生的根本原因就是…
阅读更多...
chatgpt赋能python：Python怎么调整行距

chatgpt赋能python：Python怎么调整行距

Python怎么调整行距 在Python中&#xff0c;我们可以使用不同的方法来调整文本行距。 在这篇文章中&#xff0c;我们将讨论最常用的两种方法&#xff1a;使用文本编辑器和使用Python代码。 使用文本编辑器 许多文本编辑器都具有设置行距的选项。 这通常在“格式”或“段落”…
阅读更多...
SpringBoot + Mybatis Plus 实现的瀑布内容管理系统、CMS建站系统

SpringBoot + Mybatis Plus 实现的瀑布内容管理系统、CMS建站系统

瀑布内容管理系统 瀑布内容管理系统&#xff0c;采用SpringBoot Apache Shiro Mybatis Plus Thymeleaf 实现的内容管理系统(附带权限管理)&#xff0c;是搭建博客、网站的不二之选。 项目介绍 PB-CMS&#xff0c;致力于开发最精简、实用的CMS管理系统&#xff0c;适合搭建…
阅读更多...
chatgpt赋能python：Python如何访问手机：探索移动端SEO优化的新途径

chatgpt赋能python：Python如何访问手机：探索移动端SEO优化的新途径

Python如何访问手机&#xff1a;探索移动端SEO优化的新途径 随着移动互联网的快速发展&#xff0c;移动端成为了各大搜索引擎的竞争焦点。对于SEO优化工程师而言&#xff0c;探索移动端SEO优化的新途径显得尤为关键。而Python作为一种强大的编程语言&#xff0c;在移动端SEO优…
阅读更多...
MM32F3273G8P火龙果开发板MindSDK开发教程21 - PWM的使用

MM32F3273G8P火龙果开发板MindSDK开发教程21 - PWM的使用

MM32F3273G8P火龙果开发板MindSDK开发教程21 - PWM的使用 1、简述 开发版的LED灯连接PA1脚&#xff0c;而PA1可以映射TIM2_CH2&#xff0c;所以我们用通用定时器2的TIM2_CH2输出PWM到PA1脚&#xff0c;通过更改PWM的占空比&#xff0c;来改变LED的亮度。 2、LED灯的初始化…
阅读更多...
读数据压缩入门笔记06_上下文转换

读数据压缩入门笔记06_上下文转换

1. 压缩算法可归为两类 1.1. 统计压缩&#xff08;即VLC&#xff09; 1.2. 字典压缩&#xff08;如LZ78&#xff09; 1.3. 从不同的角度利用了给定数据流中存在的统计冗余信息 2. 上下文变换 2.1. contextual transform 2.2. 给定一组相邻的符号集&#xff0c;对它们进行…
阅读更多...
代码审计——任意文件下载详解

代码审计——任意文件下载详解

为方便您的阅读&#xff0c;可点击下方蓝色字体&#xff0c;进行跳转↓↓↓ 01 漏洞描述02 审计要点03 漏洞特征04 漏洞案例05 修复方案 01 漏洞描述 网站可能提供文件查看或下载的功能&#xff0c;如果对用户查看或下载的文件不做限制&#xff0c;就能够查看或下载任意的文件&…
阅读更多...
大数据相关概念了解

大数据相关概念了解

Hadoop生态及Hive、HBase、Impala、HDFS之间的关系 Hadoop生态(什么是 Hadoop) Apache Hadoop软件库是一个框架&#xff0c;允许使用简单的编程模型在计算机集群之间对大型数据集进行分布式处理。它旨在从单个服务器扩展到数千台计算机&#xff0c;每台计算机都提供本地计算和…
阅读更多...
【雕爷学编程】Arduino动手做（112）---2.4G24L01无线模块

【雕爷学编程】Arduino动手做（112）---2.4G24L01无线模块

37款传感器与执行器的提法&#xff0c;在网络上广泛流传&#xff0c;其实Arduino能够兼容的传感器模块肯定是不止这37种的。鉴于本人手头积累了一些传感器和执行器模块&#xff0c;依照实践出真知&#xff08;一定要动手做&#xff09;的理念&#xff0c;以学习和交流为目的&am…
阅读更多...
chatgpt赋能python：Python怎么调整黑色的SEO？

chatgpt赋能python：Python怎么调整黑色的SEO？

Python怎么调整黑色的SEO&#xff1f; 在当今互联网的大环境下&#xff0c;各种搜索引擎的存在具有巨大的价值&#xff0c;特别是Google&#xff0c;百度等常用搜索引擎的SEO排名对于企业、个人品牌的宣传有着极其重要的意义。但是&#xff0c;如果出现黑色SEO的情况&#xff…
阅读更多...
Spark操作HBase的数据，实现列值的计算

Spark操作HBase的数据，实现列值的计算

本文将介绍如何使用Spark操作HBase的数据&#xff0c;实现列之间的计算&#xff0c;以特征值计算为例。特征值是指从原始数据中提取出来的具有代表性或判别性的数值&#xff0c;可以用于数据分析或机器学习等领域。本文将使用hbase-spark连接器&#xff0c;通过Spark RDD的方式…
阅读更多...
深度解析：圣湘生物的数字化转型升级之路（附方案详情）

深度解析：圣湘生物的数字化转型升级之路（附方案详情）

随着“互联网”医疗技术在医疗行业的应用不断深化&#xff0c;数字化正在加速推进IVD行业的创新。 当前&#xff0c;IVD企业应对机遇和挑战的核心是提升竞争力。 IVD企业基于企业资源&#xff0c;提升综合竞争力主要分【硬实力】和【软实力】。 一方面&#xff1a;需要企业不…
阅读更多...
跟李沐学AI；Meta可能让其开源AI模型商业化，让开发者赚钱

跟李沐学AI；Meta可能让其开源AI模型商业化，让开发者赚钱

&#x1f989; AI新闻 &#x1f680; Meta可能让其开源AI模型商业化&#xff0c;让开发者赚钱 摘要&#xff1a;Meta正考虑将其开源大语言模型&#xff08;LLM&#xff09;的下一个版本用于商业用途&#xff0c;这可以为聊天机器人等提供支持。此举可能会让更多开发者使用替代…
阅读更多...
张量分解（Cp、Tuker、Block-Term）

张量分解（Cp、Tuker、Block-Term）

张量 张量是向量或矩阵在维度空间上的高阶扩展。 一个 ( p , q ) (p,q) (p,q)型的张量 T T T被定义为一个多重线性映射。 T : V ∗ ⋯ V ∗ V ⋯ V ↦ R , T:V^* \times \dots \times V^* \times V \times \dots \times V \mapsto \R, T:V∗⋯V∗V⋯V↦R, 其中 V V V 是…
阅读更多...
用GPT4写2023高考语文作文，新课标I卷，Ⅱ卷

用GPT4写2023高考语文作文，新课标I卷，Ⅱ卷

文章目录 新课标Ⅰ卷新课标Ⅱ卷总结 每年的高考语文题目都会是热议的话题&#xff0c;今年同样也不例外。但是今年讨论的话题除了作文题目本身之外&#xff0c;对于chatgpt写出的作文会是什么样子的也​让广大网友同样期待 新课标Ⅰ卷 好的故事&#xff0c;可以帮我们更好地表达…
阅读更多...
chatgpt赋能python：Python怎么让结果同行输出

chatgpt赋能python：Python怎么让结果同行输出

Python怎么让结果同行输出 在Python编程中&#xff0c;我们经常需要打印出一系列的结果并在同一行输出。这对于输出更为整洁的结果和提高代码清晰度都是非常有帮助的。下面就让我们来介绍一些实现这一功能的方法。 方法一&#xff1a;使用 end 参数 在Python的 print() 函数…
阅读更多...
机器视觉_HALCON_模板匹配_1.CreateScaledShapeModel

机器视觉_HALCON_模板匹配_1.CreateScaledShapeModel

文章目录 一、前言二、create_scaled_shape_model 算子2.1 名称2.2 算子签名2.3 描述2.3.1 输入参数详述2.3.2 完整的预生成模型 2.4 执行信息2.5 参数2.6 执行结果2.7 可能的前驱算子2.8 可能的后继算子2.9 替代选择 一、前言 在HALCON算子手册中&#xff0c;对算子的介绍通常…
阅读更多...
chatgpt赋能python：Python访问数据库

chatgpt赋能python：Python访问数据库

Python访问数据库 Python是一种高级编程语言&#xff0c;在数据分析、科学计算和Web开发等领域都有广泛的应用。Python还有一个很强的优势就是它能够方便地访问数据库。在本文中&#xff0c;我们将介绍Python如何与数据库交互以及Python数据库API的使用。 Python的数据库API …
阅读更多...
chatgpt赋能python：Python如何访问数组中的元素

chatgpt赋能python：Python如何访问数组中的元素

Python如何访问数组中的元素 Python是一种高级编程语言&#xff0c;访问数组中的元素也非常简单。 它提供了一种简单而灵活的方式访问数组中的元素&#xff0c;这使得在Python中使用数组变得非常容易。在本文中&#xff0c;我们将介绍如何在Python中访问数组中的元素以及如何使…
阅读更多...
DecimalFormat基本用法

DecimalFormat基本用法

1.保留两位小数(截断&#xff09; 下面展示一些 内联代码片。 double num 11.256;DecimalFormat df new DecimalFormat("#.##");//指定RoundingModedf.setRoundingMode(RoundingMode.DOWN);String str df.format(num);double formatNum Double.parseDouble(str)…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023