异步编程CompletableFuture总结

在这里插入图片描述

文章目录

    • 1. 简介：
    • 2. 比较
      • 1、传统方式
      • 2、使用CompletableFuture：
        • 异步执行
        • 返回值
    • 3、组合处理：
        • anyOf
        • allof :
    • 4. 异步回调：
        • thenAccept
        • thenApply
        • whenComplete等同于 thenAccept
        • handel()等同于thenApply
    • 5. 常用方法：
      • 1、supplyAsync
      • 2、runAsync
      • 3、then*
      • 4、then*Async
      • 5、thenApply
      • 6、thenAccept
      • 7、thenRun
      • 8、thenCompose
      • 9、thenCombine
      • 10、runAfterEither
      • 11、runAfterBoth
      • 12、get()
      • 13、V get(long timeout, TimeUnit unit)
      • 14、T getNow(T valueIfAbsent)
      • 15、whenComplete
      • 16、exceptionally
      • 17、complete
      • 18、cancel
      • 19、allOf
      • 20、anyOf

1. 简介：

CompletableFuture,它其实是JDK8提供出来的，它是一种基于future异步编程的实现：
    1、以前我们执行一个异步任务，想要获得这个任务的返回值的时候，就得通过这个future加callable，这种传统方式，来进行实现，当我们要获得返回值的时候，就去调用这个future task 的get方法，当我们去调用get方法呢，会阻塞，所以像以前这种传统的异步编程，并且要获的返回结果进行处理，这种方式实现起来非常的麻烦，并且要获的返回值，会阻塞后面的代码。
    2、而当CompletableFuture来进行异步任务的话，并且我们要拿到这个返回值，进行处理，也可以异步的方式，而不会阻塞后面的代码
    3、CompletableFuture：提供了组合处理：比如我们有多个异步任务，那么这多个异步任务中，我想拿到里面最快的这一个，在我们以前传统的异步编程当中，实现起来非常麻烦，但是通过			CompletableFuture是非常的简单的，如果说我们想在这多个异步任务当中，全部执行完成之后，想去执行一些其他的，在之前实现也非常麻烦，此时就可以通过CompletableFuture来实现是非常的简单的，
    4.还支持异步回调，我们想在一个异步任务执行完成之后，去执行另一个异步任务，在以前我们必须对第一个任务进行“JOIN"等待，等第一个任务完成了之后，再去执行第二任务，或者把第二个任务，嵌套在第一个任务内，当第一个任务执行完成之后再去执行第二个任务，但是这种嵌套方式会出现我们所谓的”回调地狱“，也就是说如果你的异步任务非常的多，并且都希望按照顺序一个一个去执行的话，你需要每一个嵌套在上一个当中，这样代码的可阅读性，维护性都是非常差，那我们通过CompletableFuture，它所提供的这种异步回调，实现起来是非常简洁的

2. 比较

1、传统方式

package org.example;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @ClassName CompletableFutureTest
 * @Author JS
 * @Date 2024-05-15 23:30
 * @Version 1.0
 **/
public class CompletableFutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {

            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "futureTask1执行完成";
            }
        });
        new Thread(futureTask).start();
        //get() 方法的作用是，以阻塞的方式，获取任务执行结果
        System.out.println(futureTask.get());
        System.out.println("TODO....");
    }
}

在这里插入图片描述

2、使用CompletableFuture：

异步执行
  • runAsync()方法执行任务是没有返回值的
  • supplyAsync() 方法执行任务则支持返回值
package org.example;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName CompletableFutureDemo
 * @Author lenovo
 * @Date 2024-05-15 23:45
 * @Version 1.0
 **/
public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture future1 = CompletableFuture.runAsync(() -> {
            System.out.println("执行没有返回值的任务");
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "执行有返回的任务";
        });
        System.out.println(future2.join());
    }
}
返回值
  • get()方法抛出 (InterruptedException、ExecutionException) 检查时异常，程序必须处理）
  • join() 方法只抛出运行时异常，程序可不做处理

在这里插入图片描述

3、组合处理：

  • anyOf 返回跑的最快的那个future。最快的如果异常都玩完
  • allof 全部并行执行，执行完之后再去执行我们所需要的业务逻辑，如果需要获得返回值，需要配合thenApply，异常会抛出不影响其他任务
anyOf
package org.example;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName CompletableFutureDemo2
 * @Author lenovo
 * @Date 2024-05-15 23:52
 * @Version 1.0
 **/
public class CompletableFutureDemo2 {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "朋友小王去你家送药");

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "朋友小去你家送药");

        CompletableFuture<Object> anyFutures = CompletableFuture.anyOf(future1, future2);
        System.out.println(anyFutures.join());
    }
}

在这里插入图片描述

  • 其实这种就可以运用在我们异步任务当中，有多个备选方案，比如我们请求第三方接口，那么这第三方接口呢，他提供l多个线路，那这几个线路在某个时间段之内不确定谁更快，那么我们就可以将这几个线路，都通过 CompletableFuture 来进行异步请求，然后再通过anyOf 拿到请求最快的那一个
allof :
package org.example;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName CompletableFutureDemo3
 * @Author lenovo
 * @Date 2024-05-15 23:52
 * @Version 1.0
 **/
public class CompletableFutureDemo3 {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "朋友小王去你家送药 ");

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " 朋友小去你家送药");

        CompletableFuture<Object> anyFutures = CompletableFuture.allof(future1, future2).thenApply(
                res->{
                    return future1.join()+future2.join();
                    //todo...执行我们所需要的业务逻辑代码
                }
        );
        System.out.println(anyFutures.join());
    }
}

在这里插入图片描述

  • 如果你想在多个异步任务执行完成之后，来去执行一些业务逻辑的话，那么就可以通过allof，同样的传入多个future，allof的参数是一个可变长度的数组，然后再结合 thenApply 这个方法来进行处理，那在这个方法体当中，我们就可以将 future1 和 future2 进行 join，等待他们处理完成之后，我们就可在后面，执行我们所需要的业务逻辑代码，这种逻辑功能比较适用于多个任务，都需要并行的去执行，但是呢要拿到他们每个任务的结果，比方说我们在注册 验证的时候，首先判断，它的用户名是否被注册、手机号码是否被注册、手机验证码是否正确，如果这几项都没有问题的话，我们再去执行注册相关的业务代码。注意 allof出现异常，不影响其他任务，所以说可以针对每一个future，进行try-catch 捕捉他们的异常，如果非核心的future 他出现了异常，我们也可以考虑继续执行我们的核心业务

4. 异步回调：

  • whenComplete() 没有返回值，且返回的 CompletableFuture 为任务结果，而非回调结果

  • handle() 有返回值,且返回的CompletableFuture 为回调结果

他们两个出现异常不会中断 ，throwable 参数会接受前面的任务的异常，异常会通过get抛出到主线程

  • 链式处理

    • thenRun(Runnable runnable): 对异步任务的结果进行操作，不能传入参，也没有返回值

    • thenAccept(Consumer consumer):可传入参数

    • thenApply(Function function):可传入参数，并返回结果

他们三个出现异常后面的任务会中断，处理任务中感知不到异常，异常会通过get抛出到主线程

thenAccept
package org.example;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @ClassName CompletableFutureTest2
 * @Author lenovo
 * @Date 2024-05-16 0:25
 * @Version 1.0
 **/
public class CompletableFutureTest2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> 5)
                .thenAccept(result -> {
                    System.out.println("任务执行结果 =" + result * 3);
                }).thenAccept(result -> {
                    System.out.println("任务执行完成");
                });
    }

}

在这里插入图片描述

thenApply
package org.example;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @ClassName CompletableFutureTest2
 * @Author lenovo
 * @Date 2024-05-16 0:35
 * @Version 1.0
 **/
public class CompletableFutureTest3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture future3 = CompletableFuture.supplyAsync(() -> 5)
                .thenApply(result -> result * 3)
                .thenApply(result -> result + 3);
        System.out.println("future3:"+future3.join());

    }

}

在这里插入图片描述

whenComplete等同于 thenAccept
package org.example;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @ClassName CompletableFutureTest2
 * @Author lenovo
 * @Date 2024-05-16 0:25
 * @Version 1.0
 **/
public class CompletableFutureTest4 {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(111);
                    return 444;
                });

        CompletableFuture<Integer> future1Callback = future1.whenComplete((result, throwable)->{
            System.out.println(222);}).whenComplete((result,throwable) -> {
            System.out.println(333);
        });
        System.out.println(future1Callback.join());

    }

}

在这里插入图片描述

handel()等同于thenApply
package org.example;

import java.util.concurrent.CompletableFuture;

/**
 * @ClassName CompletableFutureTest2
 * @Author lenovo
 * @Date 2024-05-16 0:44
 * @Version 1.0
 **/
public class CompletableFutureTest5 {
    public static void main(String[] args) {
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(()-> {
                    return"返回任务结果";
                });
        CompletableFuture<String> future2Callback = future2.handle((result, throwable) ->{
                    return"返回任务结果";
                });
        System.out.println(future2Callback.join());

    }

}

在这里插入图片描述

5. 常用方法：

1、supplyAsync

  • 异步执行任务，任务有返回值
package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return "Hello";
        }, executorService);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }
}

2、runAsync

  • 异步执行任务，任务没有返回值
package com.Js;

import java.util.concurrent.*;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<Void> task = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
        }, executorService);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }
}

3、then*

  • 功能：前一个异步任务执行完，然后执行本任务

  • 当前执行thenApply()方法的线程来负责执行本任务，比如main线程，但是如果前一个异步任务还没执行完，那么main线程就不能执行本任务了，得等前一个任务执行完后才能执行本任务，这个时候就会在执行前一个任务的线程上执行本任务，这样才能保证执行顺序

package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        Supplier<String> taskA = () -> {
            System.out.println("1:" + Thread.currentThread().getName());
            return "Hello";
        };

        Function<String, String> taskB = s -> {
            System.out.println("2:" + Thread.currentThread().getName());
            return s + " World";
        };
        
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(taskA, executorService);
        sleep(1);
        future1.thenApply(taskB);

        System.out.println("haha");
        // ...

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4、then*Async

  • 会利用CompletableFuture中公共的ForkJoinPool来执行任务

5、thenApply

  • 任务类型：Function<? super T,? extends U> fn
  • 有入参，有返回值

6、thenAccept

  • 任务类型：Consumer<? super T> action
  • 有入参，无返回值

7、thenRun

  • 任务类型：Runnable action

  • 无入参，无返回值

8、thenCompose

  • 任务类型：Function<? super T, ? extends CompletionStage> fn
  • 有入参，有返回值，返回值类型只能是CompletionStage
ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return "Hello";
        }, executorService).thenCompose(s -> CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return s + " World";
        })).thenCompose(s -> CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return s + " !!!";
        }));
        
        System.out.println(future.get());
  • 按顺序执行两个并行任务

9、thenCombine

  • 任务类型：CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn

  • 有两个入参

    • 第一个参数为CompletionStage

      • 第二个参数为具体要执行的任务，认为类型为BiFunction，有两个入参，一个返回值

        • ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(3);
            return "Hello";
        }, executorService);
        CompletableFuture<String> futureB = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(3);
            return " World";
        }, executorService);
        CompletableFuture<String> result = futureA.thenCombine(futureB, (resultA, resultB) -> {
            System.out.println(Thread.currentThread().getName());
            return resultA + resultB;
        });
        System.out.println(result.get());

    • 整合两个并行执行的任务结果

10、runAfterEither

  • 两个任务中任意一个完成了，就执行回调

    • package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "Hello";
        }, executorService);

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "World";
        }, executorService);

        task2.runAfterEither(task1, () -> System.out.println("!!!"));


    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

11、runAfterBoth

  • 两个任务都完成了，才执行回调

    package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "Hello";
        }, executorService);

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
//            sleep(5);
            return "World";
        }, executorService);

        task2.runAfterBoth(task1, () -> System.out.println("!!!"));


    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

12、get()

  • 阻塞等待结果

13、V get(long timeout, TimeUnit unit)

  • 超时等待结果

14、T getNow(T valueIfAbsent)

  • 立即获取结果，如果任务还没完成，则返回valueIfAbsent

15、whenComplete

  • 入参为BiConsumer<? super T, ? super Throwable> action
    • 任务正常结束第一个参数传入的是结果
    • 任务异常结束第二个参数传入的是异常
      • 异常类型是CompletionException
  • 没有返回值

16、exceptionally

  • 入参为Function<Throwable, ? extends T> fn
    • 入参为异常
      • 异常类型是CompletionException
  • 可以返回其他值
  • 如果任务没有出现异常则不会执行

17、complete

  • 直接让任务完成
package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "Hello";
        }, executorService);

        task1.complete("haha");

        System.out.println(task1.get());

        executorService.shutdown();

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

18、cancel

  • 如果任务还没开始，或正在执行，则能取消，设置取消标记为true

    • package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task = CompletableFuture.supplyAsync(() -> {
            sleep(3);
            System.out.println(Thread.currentThread().getName());
            return "Hello";
        }, executorService);

        sleep(1);
        task.cancel(false);
        System.out.println(task.get());


    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }
}

  • 如果任务已经完成，则设置取消标记为false

19、allOf

  • 所有任务都执行完后才执行下一个任务

    package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "Hello";
        }, executorService);

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return "World";
        }, executorService);

        CompletableFuture.allOf(task1, task2).join();

        System.out.println("!!!");

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

20、anyOf

  • 任意一个任务执行完就可以执行下一个任务了

    package com.Js;

import java.util.concurrent.*;
import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executorService = Executors.newFixedThreadPool(10);

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            sleep(5);
            return "Hello";
        }, executorService);

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            return "World";
        }, executorService);

        CompletableFuture.anyOf(task1, task2).join();

        System.out.println("!!!");

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

深度优先搜索汇总

深度优先搜索汇总

常用英文 最近公共祖先&#xff08;Lowest Common Ancestor&#xff0c;简称LCA&#xff09; posterity&#xff0c;英语单词&#xff0c;主要用作名词&#xff0c;作名词时译为“子孙&#xff0c;后裔&#xff1b;后代”。 什么是深度优先搜索 深度优先搜索&#xff0c;D…
阅读更多...
【简单介绍下在Ubuntu中如何设置中文输入法】

【简单介绍下在Ubuntu中如何设置中文输入法】

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
二.使用PgAdmin连接Postgresql

二.使用PgAdmin连接Postgresql

二．使用PgAdmin连接Postgresql PostgreSQL是一种开源的对象关系型数据库管理系统（ORDBMS），它支持大部分SQL标准并提供了许多高级功能，例如事务、外键、视图、触发器等。PostgreSQL由PostgreSQL全球开发组维护和开发，它是一种高度可扩展的数据库系统，可以在各种操作系统…
阅读更多...
echarts 时间线

echarts 时间线

echarts 时间线 &#xff08;下面附有完整示例&#xff09; 实现思路 1、先分析图片是由一根y轴线和每个小节点组成&#xff1b; 2、可以看出时间线是没有轴的&#xff0c;所以将“ xAxis ”属性隐藏&#xff1b; 3、y轴是没有分割线的所以隐层“ yAxis ”中的“ splitLine ”…
阅读更多...
AI网络爬虫：用kimi提取网页中的表格内容

AI网络爬虫：用kimi提取网页中的表格内容

一个网页中有一个很长的表格&#xff0c;要提取其全部内容&#xff0c;还有表格中的所有URL网址。 在kimi中输入提示词&#xff1a; 你是一个Python编程专家&#xff0c;要完成一个编写爬取网页表格内容的Python脚步的任务&#xff0c;具体步骤如下&#xff1a; 在F盘新建一个…
阅读更多...
控制状态流程图中的消息活动

控制状态流程图中的消息活动

消息是一个Stateflow对象&#xff0c;用于在本地或图表之间进行数据通信。从发件人图表中&#xff0c;您可以发送或转发邮件。在接收图表中&#xff0c;队列接收消息并将其保存&#xff0c;直到图表能够对其进行评估。 使用Stateflow运算符&#xff0c;您可以访问消息数据&…
阅读更多...
[PythonWeb：Django框架]：项目初始化搭建

[PythonWeb：Django框架]：项目初始化搭建

文章目录 pip查看安装列表安装制定Django版本初始化django项目执行 python manage.py startapp projectName 生成app应用执行 python manage.py runserver 运行web项目settings.py注入应用配置django项目页面访问地址注意&#xff1a;再次访问地址&#xff0c;返回制定页面 pip…
阅读更多...
【ubuntu】ubuntu-18.04开机卡在Starting User Manager for UID 120....问题解决方案

【ubuntu】ubuntu-18.04开机卡在Starting User Manager for UID 120....问题解决方案

错误截图 解决方案 启动系统&#xff0c;开机界面单击按键esc键&#xff0c;注意需要将鼠标定位到菜单界面&#xff0c;移动键盘上下键选择Advanced options for Ubuntu 进入如下菜单&#xff0c;选择recovery mode 回车之后会弹出如下界面&#xff0c;选择如下root&#xff0…
阅读更多...
爬虫界的“闪电侠”：异步爬虫与分布式系统的实战秘籍

爬虫界的“闪电侠”：异步爬虫与分布式系统的实战秘籍

Hi&#xff0c;我是阿佑&#xff0c;前文给大家讲了&#xff0c;如何做一个合法“采蜜”的蜜蜂&#xff0c;有了这么个自保的能力后&#xff0c;阿佑今天就将和大家踏入 —— 异步爬虫 的大门&#xff01; 异步爬虫大法 1. 引言1.1 爬虫框架的价值&#xff1a;效率与复杂度管理…
阅读更多...
得物面试：Redis 内存碎片是什么？如何清理？

得物面试：Redis 内存碎片是什么？如何清理？

> **插&#xff1a;** [AI时代&#xff0c;程序员或多或少要了解些人工智能&#xff0c;前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。](前言 – 床长人工智能教程 ) **坚持不懈&…
阅读更多...
Django创建网站的地基

Django创建网站的地基

相关文档 1、为新网站创建一个文件夹&#xff08;这里是&#xff1a;locallibrary&#xff09; D:\django>mkdir locallibraryD:\django>cd locallibraryD:\django\locallibrary>dirVolume in drive D is 新加卷Volume Serial Number is B68C-03F7Directory of D:\dj…
阅读更多...
基于SpringBoot设计模式之创建型设计模式·生成器模式

基于SpringBoot设计模式之创建型设计模式·生成器模式

文章目录 介绍开始架构图样例一定义生成器定义具体生成器&#xff08;HTML格式、markdown格式&#xff09;实体类HTML格式生成器MarkDown格式生成器 测试样例 总结优点缺点 介绍 将一个复杂对象的构建与它的表示分离&#xff0c;使得同样的构建过程可以创建不同的表示。   如…
阅读更多...
C++ | Leetcode C++题解之第91题解码方法

C++ | Leetcode C++题解之第91题解码方法

题目&#xff1a; 题解&#xff1a; class Solution { public:int numDecodings(string s) {int n s.size();// a f[i-2], b f[i-1], c f[i]int a 0, b 1, c;for (int i 1; i < n; i) {c 0;if (s[i - 1] ! 0) {c b;}if (i > 1 && s[i - 2] ! 0 &&a…
阅读更多...
每日一题13：Pandas:方法链

每日一题13：Pandas:方法链

一、每日一题 &#xff1b;&#xff1a;&#xff1a; 解答&#xff1a; import pandas as pddef findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame:heavy_animals animals[animals[weight] > 100].sort_values(byweight, ascendingFalse)result heavy_anim…
阅读更多...
ssm132医院住院综合服务管理系统设计与开发+vue

ssm132医院住院综合服务管理系统设计与开发+vue

医院住院综合服务管理系统的设计与实现 摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对医院住院信息管理混乱&…
阅读更多...
低代码开发平台在城市数字化转型中的技术实现与案例分析

低代码开发平台在城市数字化转型中的技术实现与案例分析

城市数字化转型需要政策引导、技术创新、基础设施建设、人才培养、多方合作以及安全保障等全方位的支持与助力&#xff0c;共同推动城市的数字化进程&#xff0c;提升其竞争力和可持续发展能力。 其中&#xff0c;技术创新是推动数字化转型的核心动力&#xff0c;需要不断加强…
阅读更多...
【kubernetes】集群的二进制部署安装

【kubernetes】集群的二进制部署安装

目录 一、环境部署 二、部署 docker引擎 三、部署 etcd 集群 1、准备签发证书环境 1.1 master01服务器配置 1.1.1 准备cfssl证书生成工具 1.1.2 生成Etcd证书 1.1.3 创建存放etcd配置文件&#xff0c;命令文件&#xff0c;证书的目录&#xff0c;并启动etcd服务 1.1.4…
阅读更多...
Android中使用Palette让你的页面UI优雅起来

Android中使用Palette让你的页面UI优雅起来

文章目录 1. 什么是Palette2. 引入Palette3. 使用 Palette3.1 同步方式3.2 异步方式3.3 获取色调值 4. 举例4.1 布局文件 activity_palette_list.xml ⬇️4.2 Activity&#xff1a;PaletteListActivity⬇️4.3 列表Adapter&#xff1a;PaletteListAdapter ⬇️4.4 列表item布局…
阅读更多...
数字化智能：Web3时代的物联网创新之路

数字化智能：Web3时代的物联网创新之路

引言 随着科技的不断发展&#xff0c;物联网&#xff08;IoT&#xff09;技术正在迅速普及和应用。而随着Web3时代的到来&#xff0c;物联网将迎来新的发展机遇和挑战。本文将探讨Web3时代的物联网创新之路&#xff0c;深入分析其核心技术、应用场景以及未来发展趋势。 Web3时…
阅读更多...
kk聊天室系统源码搭建-自适应手机电脑-秒级响应-群体消息

kk聊天室系统源码搭建-自适应手机电脑-秒级响应-群体消息

kk聊天室系统源码搭建-自适应手机电脑-秒级响应-群体消息-单体消息 可以无限创建聊天室&#xff0c;可以把单个聊天室链接拿出来单独使用&#xff0c;消息秒级响应&#xff0c;支持设置屏蔽词。 具体仔细看视频演示&#xff0c;不提供演示&#xff0c;因为青狐资源网会员用户太…
阅读更多...
最新文章

Copyright @ 2022~2023