giao卤蛋
giao卤蛋

异步线程池

异步&线程池

为了节约时间和提高吞吐量，我们要做一些异步请求

1、初始化线程的4种方式

​ 1，继承Thread

​ 2，实现Runnable接口

​ 3，实现Callable接口+FutureTask（可以拿到返回结果，可以处理异常）

​ 4，线程池

方式1和方式2：主线程无法获取线程的运算结果。不适合当前场景

方式3：主进程可以获取线程的运算结果，但是不利于控制服务器中的线程资源。可以导致服务器资源耗尽

方式4：通过如下两种方式初始化线程池

Executors.newFiexedThreadPool(3);
//或者
new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,TimeUnit,unit,workQueue,threadFactory,handler)

通过线程池性能稳定，也可以获取执行结果，并捕获异常。但是，在业务复杂情况下，一个异步调用可能会依赖于另一个异步调用的执行结果。

方式一实现代码如下：

1，继承Thread
public class ThreadTest {
    public static void main(String[] args) {
           System.out.println("main....start....");
           Thread01 thread01 = new Thread01();
           thread01.start();//启动线程
           System.out.println("main....end....");
        }
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果: "+i);
        }
    }
}

main....start....
main....end....
当前线程：12
运行结果：5

方式二实现代码如下

2，实现Runnable接口
       public static class Runable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果: "+i);
        }
    }

main方法中
        System.out.println("main....start....");
       	Runable01 runable01 = new Runable01();
        new Thread(runable01).start();
        System.out.println("main....end....");

main....start....
main....end....
当前线程：12
运行结果：5

第三种方式

public static class Callable01 implements Callable{
        @Override
        public Object call() throws Exception {
            System.out.println("当前线程: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果: "+i);
            return i;
        }
    }

main方法中
    FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
    new Thread(futureTask).start();
System.out.println("main....end....");

可以看到Callable接口中直接结束了

异步线程池_第1张图片

所以我们将采取FutureTask的方式来启动Callable的线程，根据FutureTask源码

异步线程池_第2张图片

继而new出来返回FutureTask，FutureTask又继承RunnableFuture，而RunnableFuture又分别继承Runnable,Future

异步线程池_第3张图片

所以它的启动方式就是FutureTask futureTask = new FutureTask<>(new Callable01());new Thread(futureTask).start();

运行结果如下

main....start....
main....end....
当前线程：12
运行结果：5

Callable最大的好处是FutureTask 我们假设后台运行的很慢，我们还希望后台返回这个Callable的计算结果，就可以使用FutureTask ，它有一个方法.get

等异步方法执行完，返回它的结果

Integer integer = futureTask.get();
//等待整个线程执行完成，获取返回结果


修改main方法
    Integer integer = futureTask.get();
System.out.println("main....end...."+integer);


	main....start....
当前线程：12
运行结果：5
main....end....+5

所以Integer integer = futureTask.get();是一个阻塞等待

futureTask不仅可以接受Callable，还接受Runnable，如果是Runnable，还可以传一个对象，让这个对象接受参数

异步线程池_第4张图片

第四种方式

给线程池直接提交任务。

为什么使用线程池？如果我们后来的项目中异步比较多，每次都进行原生代码new Thread().start()，没执行一个线程就开启一个start（存在问题）

我们以后在业务代码里，以上三种启动线程的方式都不能用 避免大量new Thread造成资源消耗完，应该将所有的多线程异步任务交给线程池执行

JUC中最快得到线程池

ExecutorService executorService = Executors.newFixedThreadPool(10);
//10代表有十个空闲线程   当前系统中池只有一两个，每个异步任务，提交给线程让他自己去执行就行

并不应该是每运行一次就创建一个线程池，应该是一个线程池，大家将所有任务都交给这个线程池来处理

要想访问线程池

public static ExecutorService executorService = Executors.newFixedThreadPool(10);

异步线程池_第5张图片

里面有submit，可以将一个Runnable或Callable的任务，或者使用execute让它执行

submit跟execute两个区别

如果是submit给线程池中添加一个任务，我们可以获取任务的返回值；如果是execute，直接让线程池执行我们这个操作，返回类型是void 都是给线程池提交异步请求

main中执行
 executorService.execute(new Runable01());

main....start....
main....end....
当前线程：12
运行结果：5

这是我们将任务提交给线程池，而不是我们自己在new

 给线程池直接提交任务。
         * executorService.execute(new Runable01());
         * 1，创建
         *   1）Executors
         *   2）new ThreadPoolExecutor();
         *   Future:可以获得到异步结果
         *
         * 区别
         * 1，2不能获取返回值3可以获取返回值
         * 1，2，3都不能控制资源
         * 4，可以控制资源，性能稳定
         *
         */

2，线程池的七大参数

/**
         * int corePoolSize【5】, 我们的线程数量总是在池中保持着  就算系统当前是空闲的，也是在池总一直有的，等待接收新任务的 除非设置allowCoreThreadTimeOut（允许核心线程超时，这样核心线程空闲就被回收了,否则就不回收)
         * 核心线程数[一直存在除非设置allowCoreThreadTimeOut]  线程池  创建好以后准备就绪的线程数量，就等待来接受异步任务去执行  5个 Thread thread = new Thread()  thread.start()
         int maximumPoolSize, 相当于线程池最大数量；控制资源并发
         long keepAliveTime,存活时间  如果当前我们线程数量大于核心线程数的时候  释放空闲线程（maximumPoolSize-corePoolSize）  只要线程空闲大于指定keepAliveTime
         TimeUnit unit, 时间单位
         BlockingQueue<Runnable> workQueue,阻塞队列  如果任务有很多，就会将目前多的任务放在队列里面   只要有线程空闲，就会去队列里面取出新的任务继续执行
         ThreadFactory threadFactory, 线程的创建工厂
         RejectedExecutionHandler handler  如果队列满了，按照我们指定的拒绝策略拒绝执行任务（默认使用丢弃策略AbortPolicy）

         工作顺序：
         1）线程池创建好，准备好core数量的核心线程，准备接受任务
         1.1core满了，就将再进来的任务放到阻塞队列中，空闲的core就会自己去阻塞队列获取任务执行
         1.2阻塞队列满了，就直接开新线程执行，最大只能开到max指定的数量
         1.3max满了就用拒绝策略RejectedExecutionHandler拒绝任务
         1.4max都执行完成，有很多空闲  在指定的时间【keepAliveTime】以后，释放max-core这些线程

         new LinkedBlockingDeque<>():默认是Integer的最大值。内存不够

         */

  ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
                );

默认ThreadFactory

异步线程池_第6张图片

拒绝策略（默认使用丢弃策略AbortPolicy）

异步线程池_第7张图片

一个简单面试题：

一个线程池core7 max20 queue 50 100并发进来怎么分配
首先 7个会立即得到执行 50个进入队列 再开13个进行执行 剩下30个采用拒绝策略
如果不想抛弃还要执行 CallerRunsPolicy；同步方法   也可以尝试使用抛弃以前老数据

3，Executors中常见四种线程池

  • newCachedThreadPool() core是0，所有都可以回收

    异步线程池_第8张图片

    创建一个可缓存线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程

  • newFixedThreadPool() 固定大小 core=max 都不可被回收

    异步线程池_第9张图片

    创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

  • newScheduledThreadPool() 定时任务线程池

    异步线程池_第10张图片

    创建一个定长线程池，支持定时及周期性任务执行

  • newSingleThreadExecutor() 单线程的线程池，后台从队列里面获取任务 挨个执行

    异步线程池_第11张图片

    4，开发中为什么使用线程池

    • 降低资源的消耗

      • 通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗

    • 提高响应速度

      • 因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行

    • 提高线程的可管理性

      • 线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁不仅会消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配。

CompletableFuture异步编排

业务场景：

查询商品详情页的逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多时间

异步线程池_第12张图片

假如商品详细页的每个查询，需要如下标注的时间才能完成

那么，用户需要5.5s才能看到商品详细页的内容。很显然是不能接受的

如果多个线程同时完成这6步，也许就只需要1.5s就完成响应

Future是Java5添加的类，用来描述一个异步计算的结果，你可以使用’isDone‘方法检查计算是否完成，或者使用’get‘阻塞猪调用线程，直到计算完成返回结果，你也可以使用’cancel‘方法停止任务执行

虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不 方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的 初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果，为 什么不能用观察者设计模式当计算结果完成及时通知监听者呢？ 很多语言，比如 Node.js，采用回调的方式实现异步编程。Java 的一些框架，比如 Netty，自 己扩展了 Java 的 Future接口，提供了addListener等多个扩展方法；Google guava 也提供了 通用的扩展 Future；Scala 也提供了简单易用且功能强大的 Future/Promise 异步编程模式。 作为正统的 Java 类库，是不是应该做点什么，加强一下自身库的功能呢？ 在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的 Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以 通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。 CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过get方法阻塞或 者轮询的方式获得结果，但是这种方式不推荐使用

CompletableFuture 和 FutureTask 同属于 Future 接口的实现类，都可以获取线程的执行结果。

异步线程池_第13张图片

CompletableFuture是jdk1.8以后添加的功能 CompletableFuture就类似于vue中promise的ajax请求，执行完了就.then

CompletableFuture提供了四个静态方法来创建一个异步操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Im8GqjtU-1651988685326)(C:\Users\靓仔在此\AppData\Roaming\Typora\typora-user-images\image-20220507233226681.png)]

1创建异步对象

 public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        System.out.println("main....start....");
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
        }, executor);
        System.out.println("main....end....");
        executor是定义好的线程池，如果没有定义就用默认的
             public static ExecutorService executor = Executors.newFixedThreadPool(10);
        无返回值

main....start....
main....end....
当前线程: 12
运行结果: 5

  CompletableFuture.supplyAsync(()->{
            System.out.println("当前线程: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果: "+i);
            return i;
        },executor);
   executor是定义好的线程池，如果没有定义就用默认的
             public static ExecutorService executor = Executors.newFixedThreadPool(10);
有返回值

main....start....
main....end....
当前线程: 12
运行结果: 5

 System.out.println("main....start....");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
            return i;
        }, executor);
        Integer integer = future.get();
        System.out.println("main....end...."+integer);
    }
   executor是定义好的线程池，如果没有定义就用默认的
             public static ExecutorService executor = Executors.newFixedThreadPool(10);
有返回值

main....start....
当前线程: 12
运行结果: 5
main....end....5

2计算完成时回调方法

异步线程池_第14张图片

whenCompletable可以处理正常和异常的计算结果，exceptionally处理异常情况

whenCompletable和whenCompletableAsync的区别：

  • whenCompletable：是执行当前任务的线程执行继续执行whenCompletable的任务
  • whenCompletableAsync：是执行把whenCompletableAsync这个任务继续提交给线程池来进行执行

方法不以Asyc结尾，意味着Action使用相同的线程执行，而Asyc可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

whenComplete没有异常

 System.out.println("main....start....");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).whenComplete((res,excption)->{
            System.out.println("异步任务成功完成了。。。结果是："+res+"；异常是："+excption);
        });
//        Integer integer = future.get();
        System.out.println("main....end....");

main....start....
当前线程: 12
运行结果: 5
异步任务成功完成了。。。结果是：5；异常是：null
main....end....

whenComplete有异常

System.out.println("main....start....");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).whenComplete((res,excption)->{
            System.out.println("异步任务成功完成了。。。结果是："+res+"；异常是："+excption);
        });
//        Integer integer = future.get();
        System.out.println("main....end....");

main....start....
当前线程: 12
main....end....
异步任务成功完成了。。。结果是：null；异常是：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero

出现异常后还能进行处理exceptionally 异常处理逻辑

  System.out.println("main....start....");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).whenComplete((res,excption)->{
            //虽然能得到异常信息，但是没法修改返回数据
            System.out.println("异步任务成功完成了。。。结果是："+res+"；异常是："+excption);
        }).exceptionally(throwable -> {
            //可以感知异常，同时返回默认值
            return 10;
        });
                //R apply(T,t);
        Integer integer = future.get();
        System.out.println("main....end...."+integer);
    }

main....start....
当前线程: 12
异步任务成功完成了。。。结果是：null；异常是：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
main....end....10

3handle方法

异步线程池_第15张图片

和complete一样，可对结果做最后的处理（可处理异常），可改变返回值

有异常时
     //方法执行完成后的处理，无论是成功完成还是失败完成
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).handle((res,thr)->{
            if (res!=null){
                return res*2;
            }
            if (thr!=null){
                return 0;
            }
            return 0;
        });
//        R apply(T t, U u);
        Integer integer = future.get();
        System.out.println("main....end...."+integer);
    }

main....start....
当前线程: 12
main....end....0
因为有异常，handle就将返回值修改为0

无异常时
     //方法执行完成后的处理，无论是成功完成还是失败完成
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2
            System.out.println("运行结果: " + i);
            return i;
        }, executor).handle((res,thr)->{
            if (res!=null){
                return res*2;
            }
            if (thr!=null){
                return 0;
            }
            return 0;
        });
//        R apply(T t, U u);
        Integer integer = future.get();
        System.out.println("main....end...."+integer);
    }

main....start....
当前线程: 12
运行结果: 5
main....end....10

异步返回结果为5，在handle中被修改了

4线程串行化方法

异步线程池_第16张图片

thenApply方法：当一个线程依赖另一个线程时，获取上一个任务的返回的结果，并返回当前任务的返回值

异步线程池_第17张图片

异步线程池_第18张图片

 /**
         * 线程串行化
         * 1）thenRun:不能获取到上一步的执行结果，无返回值
         * .thenRunAsync(() -> {
         *             System.out.println("任务二启动了。。。。");
         *         }, executor);
         *2)thenAcceptAsync:能接收上一步结果，但是无返回值
         *.thenAcceptAsync(res->{
         *              System.out.println("任务二启动了"+res);
         *          },executor);
         *3)thenApplyAsync：能接收上一步结果，有返回值
         */   
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务二启动了" + res);
            return "Hello" + res;
        }, executor);
        //future.get()是一个阻塞方法
        System.out.println("main....end...."+future.get());
    }

main....start....
当前线程: 12
运行结果: 5
任务二启动了5
main....end....Hello5

thenAccept方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果

image-20220508102236075

异步线程池_第19张图片

 /**
         * 线程串行化
         * 1）thenRun:不能获取到上一步的执行结果，无返回值
         * .thenRunAsync(() -> {
         *             System.out.println("任务二启动了。。。。");
         *         }, executor);
         *2)thenAcceptAsync:能接收上一步结果，但是无返回值
         *.thenAcceptAsync(res->{
             System.out.println("任务二启动了"+res);
         },executor);
         */
         CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).thenAcceptAsync(res->{
             System.out.println("任务二启动了"+res);
         },executor);
        System.out.println("main....end....");
    }

main....start....
当前线程: 12
运行结果: 5
main....end....
任务二启动了5

thenRun方法：只要上面的任务执行完成，就开始执行thenRun，只是处理完任务后，执行thenRun的后续操作


        /**
         * 线程串行化
         * 1）thenRun:不能获取到上一步的执行结果
         * .thenRunAsync(() -> {
            System.out.println("任务二启动了。。。。");
        }, executor);
         */
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果: " + i);
            return i;
        }, executor).thenRunAsync(() -> {
            System.out.println("任务二启动了。。。。");
        }, executor);
        System.out.println("main....end....");
    }

main....start....
当前线程: 12
运行结果: 5
main....end....
任务二启动了。。。。

带有Async默认是异步执行的，同之前。

以上都要前置任务成功完成

5两任务组合-都要完成

异步线程池_第20张图片

异步线程池_第21张图片

两个任务必须都完成，触发该任务

thenCombine:组合两个future，获取两个future的返回结果，并返回当前任务的返回值

异步线程池_第22张图片

异步线程池_第23张图片

 /**
         * 两个都完成
         */
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            System.out.println("任务二结束: ");
            return "hello";
        }, executor);
//        R apply(T t, U u);
        CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1 + "：" + f2 + "->giao";
        }, executor);
        System.out.println("main....end...."+future.get());
    }



main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
任务二结束: 
main....end....5：hello->giao

thenAcceptBoth:组合两个future，获取两个future的返回结果，然后处理任务，没有返回值

异步线程池_第24张图片

 /**
         * 两个都完成
         */
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            System.out.println("任务二结束: ");
            return "hello";
        }, executor);
//        void accept(T t, U u);
        future01.thenAcceptBothAsync(future02,(f1,f2)->{
            System.out.println("任务3开始。。。之前的结果："+f1+".....>"+f2);
        },executor);
        System.out.println("main....end....");
    }

main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
任务二结束: 
main....end....
任务3开始。。。之前的结果：5.....>hello

runAfterBoth:组合两个future，不需要获取future的结果，只需要两个future处理完任务后，处理该任务

异步线程池_第25张图片

  /**
         * 两个都完成
         */
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            System.out.println("任务二结束: ");
            return "hello";
        }, executor);

        future01.runAfterBothAsync(future02,()->{
            System.out.println("任务三开始");
        },executor);
        System.out.println("main....end....");
    }

main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
任务二结束: 
main....end....
任务三开始

6两个任务组合-一个完成

异步线程池_第26张图片

当两个任务中，任意一个 future 任务完成的时候，执行任务。

applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。

   /**
         * 两个任务，只要有一个完成，我们就执行任务3
         * runAfterEitherAsync:不感知结果，自己没有返回值
         * acceptEitherAsync:感知结果，自己没有返回值
         * applyToEitherAsync：自己感知结果，有返回值
         */      
CompletableFuture<String> future = future01.applyToEitherAsync(future02, (res) -> {
            System.out.println("任务3开始。。。之前的结果" + res);
            return res.toString() + "->giao";
        }, executor);

        System.out.println("main....end...."+future.get());
    }

main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
任务3开始。。。之前的结果5
main....end....5->giao
任务二结束:

acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
异步线程池_第27张图片

 CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
                System.out.println("任务二结束: ");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, executor);


        /**
         * 两个任务，只要有一个完成，我们就执行任务3
         * runAfterEitherAsync:不感知结果，自己没有返回值
         * acceptEitherAsync:感知结果，自己没有返回值
         */
       /* future01.runAfterEitherAsync(future02,()->{
            System.out.println("任务3开始。。。之前的结果");
        },executor);*/

        future01.acceptEitherAsync(future02,(res)->{
            System.out.println("任务3开始。。。之前的结果"+res);
        },executor);
        System.out.println("main....end....");
    }


main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
main....end....
任务3开始。。。之前的结果
任务二结束:

runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返 回值

 /**
         * 两个任务，只要有一个完成，我们就执行任务3
         */
        future01.runAfterEitherAsync(future02,()->{
            System.out.println("任务3开始。。。之前的结果");
        },executor);
        System.out.println("main....end....");
    }


 CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            System.out.println("任务二结束: ");
            return "hello";
        }, executor);

main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
任务二结束: 
main....end....
任务3开始。。。之前的结果

这个操作两个线程都完成了，无法查看runAfterEither的效果所以对代码future02作出修改

CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一线程启动了: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务一结束: ");
            return i;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二线程启动了: " + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
                System.out.println("任务二结束: ");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, executor);


  /**
         * 两个任务，只要有一个完成，我们就执行任务3
         * runAfterEitherAsync:不感知结果，自己业务返回值
         */
        future01.runAfterEitherAsync(future02,()->{
            System.out.println("任务3开始。。。之前的结果");
        },executor);
        System.out.println("main....end....");
    }

main....start....
任务一线程启动了: 12
任务一结束: 
任务二线程启动了: 13
main....end....
任务3开始。。。之前的结果
任务二结束:

7多任务组合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8fqmY4S8-1651988685333)(C:\Users\靓仔在此\AppData\Roaming\Typora\typora-user-images\image-20220508113138087.png)]

allOf：等待所有任务完成

CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片信息");
            return "hello.jpg";
        });

        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品de属性");
            return "黑色+256G";
        });

        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品介绍");
            return "华为";
        });

//        futureImg.get();
//        futureAttr.get();
//        futureDesc.get();
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
        allOf.get();//等待所有结果完成
//        allOf.join();


main....start....
查询商品图片信息
查询商品de属性
查询商品介绍
main....end....

当一个线程执行比较慢时

  CompletableFuture futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片信息");
            return "hello.jpg";
        });

        CompletableFuture futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品de属性");
            return "黑色+256G";
        });

        CompletableFuture futureDesc = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品介绍");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "华为";
        });

//        futureImg.get();
//        futureAttr.get();
//        futureDesc.get();
        CompletableFuture allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
//        allOf.get();//等待所有结果完成
//        allOf.join();

        System.out.println("main....end....");
    }

输出结果居然没有查询商品介绍 所有任务都没执行完就结束了

main....start....
查询商品图片信息
查询商品de属性
main....end....

改为线程池 无线存活阻塞

CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片信息");
            return "hello.jpg";
        },executor);

        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品de属性");
            return "黑色+256G";
        },executor);

        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品介绍");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "华为";
        },executor);

//        futureImg.get();
//        futureAttr.get();
//        futureDesc.get();
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
//        allOf.get();//等待所有结果完成
//        allOf.join();

        System.out.println("main....end....");
    }



main....start....
查询商品图片信息
查询商品de属性
main....end....
查询商品介绍

所以还不如直接

        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
     allOf.get();//等待所有结果完成

想要获取到future中的内容

System.out.println("main....end...."+futureImg.get()+"=>"+futureAttr.get()+"=>"+futureDesc.get());

main....start....
查询商品图片信息
查询商品de属性
查询商品介绍
main....end....hello.jpg=>黑色+256G=>华为

anyOf：只要有一个任务完成

    CompletableFuture anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
        anyOf.get();
 
  
main....start....
查询商品图片信息
查询商品de属性
main....end....hello.jpg
查询商品介绍

 
  
 } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "华为";
    },executor);

 
  
// futureImg.get();
 // futureAttr.get();
 // futureDesc.get();
 CompletableFuture allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
 // allOf.get();//等待所有结果完成
 // allOf.join();
 
  
    System.out.println("main....end....");
}

 
  



```console
main....start....
查询商品图片信息
查询商品de属性
main....end....
查询商品介绍

 
  
所以还不如直接
 
  
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
     allOf.get();//等待所有结果完成

 
  
想要获取到future中的内容
 
  
System.out.println("main....end...."+futureImg.get()+"=>"+futureAttr.get()+"=>"+futureDesc.get());

 
  
main....start....
查询商品图片信息
查询商品de属性
查询商品介绍
main....end....hello.jpg=>黑色+256G=>华为

 
  
anyOf：只要有一个任务完成
 
  
    CompletableFuture anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
        anyOf.get();
 
  
main....start....
查询商品图片信息
查询商品de属性
main....end....hello.jpg
查询商品介绍

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java,java,开发语言)

        

            

                
    
                    
  • JavaScript的那些不可不知的知识
                        遇见~未来
JavaScriptjavascript开发语言ecmascript
                        
    目录JavaScript基础JavaScript高级JavaScript基础数据类型：JavaScript的数据类型分为基本数据类型和引用数据类型。基本数据类型包含number（数字）、string（字符串）、boolean（布尔值）、null（空值）、undefined（未定义）。而像array（数组）、function（函数）等则属于引用数据类型。在内存存储方面，基本类型是按值存储在栈中，引用
    
                    
    • 
                    
  • Java并发编程：线程安全的策略与实践
                        喵手
零基础学Javajava安全开发语言
                        
    哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式
    
                    
    • 
                    
  • SpringBoot+restFul+filter+threadLocal实现多租户的项目
                        梦想一直在路上

                        
    本片博客参考了https://blog.csdn.net/gebitan505/article/details/51614805threadLocal的目的是:实现变量的全局话,在当前的项目当中是实现了用户名的多租户状态下的全局话fiter:进行token的拦截,ThreadLocal的代码packagecom.zwl.util;importjava.util.HashMap;importjava
    
                    
    • 
                    
  • 工作流开发过程
                        Dev2010Daily
软件开发基础知识工作jbpm引擎java
                        
    1、首先要识别出工作流，即找出候选的工作流。2、可视化流程建模，此处将用到的是jBPM(jBPMGraphicalProcessDesignerGPD)editor3、开发运行时的元件4、布署运行时引擎jBPM提供了多种不同的布署场景：（1）引擎与实例同时使用---jBPMConsole（2）用JAVA类实例来实例化引擎5、实例化运行时实例6、监控和审计
    
                    
    • 
                    
  • javamail发( 收)邮件
                        sageparadise
Javajavamailstringexception邮件服务器emailproperties
                        
    MyAuthenticator.javapackagecn.com.vetc.survey.mail;importjavax.mail.Authenticator;importjavax.mail.PasswordAuthentication;publicclassMyAuthenticatorextendsAuthenticator{privateStringuserName=null;priv
    
                    
    • 
                    
  • 《中型 Vue 项目：挑战与成长》
                        计算机毕设定制辅导-无忧学长
#Vuevue.jsflutter前端
                        
    一、引言在当今的前端开发领域，Vue作为一款渐进式JavaScript框架，以其强大的功能和灵活性备受开发者青睐。对于中型Vue项目而言，其重要性不言而喻。中型Vue项目通常在功能复杂度和规模上介于小型项目和大型项目之间，既需要应对一定的业务需求挑战，又要考虑开发效率和可维护性。中型Vue项目面临着诸多挑战与机遇。挑战方面，随着项目规模的扩大，代码的复杂性增加，如何进行有效的状态管理、组件化开发以
    
                    
    • 
                    
  • 中型项目中 MyBatis 的挑战与应对
                        计算机毕设定制辅导-无忧学长
#MyBatismybatis
                        
    一、引言在当今的Java企业级开发领域，MyBatis无疑是一款占据重要地位的持久层框架。它像是一座桥梁，优雅地连接着Java应用程序与数据库，让数据的交互变得高效且便捷。当我们聚焦于中型项目时，随着业务复杂度的提升以及数据量的增长，MyBatis在为我们带来便利的同时，也悄然面临着诸多挑战。这些挑战涵盖了从性能瓶颈到代码维护性，从数据库兼容性到事务管理等多个关键层面。深入探究这些问题并找寻有效的
    
                    
    • 
                    
  • npm介绍
                        小玉起起
vuejsnpm前端node.js
                        
    npm（NodePackageManager）是Node.js的默认包管理工具，用于管理JavaScript和Node.js项目的依赖关系。它既是一个包管理工具，又是一个在线仓库，开发者可以通过它分享和下载开源的JavaScript库和工具。npm是世界上最大的开源软件注册表，托管着超过一百万个包。主要功能和特点1.包管理npm的核心功能是管理依赖包。它允许开发者方便地安装、更新和删除项目中的依赖
    
                    
    • 
                    
  • JAVA基础语句整理
                        chengxuyuan66666
javapython开发语言
                        
    Java是一种广泛使用的面向对象编程语言，它具有简洁、强大、跨平台等特性。以下是Java中的一些基础语句和概念，适合初学者了解：1.类与对象Java是基于类的，程序的基本单位是类（class）。对象是类的实例。java复制代码//定义一个类publicclassPerson{//属性（成员变量）Stringname;intage;//方法（成员函数）voidintroduce(){System.o
    
                    
    • 
                    
  • 【Java多线程】断点续传 如何使用Java多线程下载网络文件
                        
java多线程
                        
    如何使用Java多线程下载网络文件,并实现断点续传在现代网络应用中，多线程下载是一种常见的技术，它可以显著提高下载速度并提供更好的用户体验。本篇文章将介绍如何使用Java实现多线程下载，并结合项目中的代码作为示例进行讲解。1.多线程下载的基本原理多线程下载的基本思想是将一个文件分成多个部分，每个部分由一个线程独立下载，最后将这些部分合并成完整的文件。这样可以充分利用带宽和计算资源，提高下载速度。使
    
                    
    • 
                    
  • 如何使用Java爬虫获取微店商品详情：代码示例与实践指南
                        小爬虫程序猿
java爬虫开发语言
                        
    在电商领域，获取商品详情数据对于商家和开发者来说至关重要。微店作为国内知名的电商平台，提供了丰富的商品数据接口，方便开发者通过API调用获取商品详情。以下将详细介绍如何使用Java爬虫获取微店商品详情，并提供具体的代码示例。一、微店商品详情API接口简介微店提供了商品详情API接口（micro.item.get），用于获取指定商品的详细信息。通过该接口，开发者可以快速获取商品的标题、价格、库存、描
    
                    
    • 
                    
  • AI时代的前端开发：技能提升与职业发展之路
                        
前端
                        
    在瞬息万变的科技时代，个人职业发展的重要性日益凸显。提升技能，不断学习，已经不再是锦上添花，而是立足之本，是我们在竞争激烈的职场中脱颖而出的关键。而人工智能（AI）技术的快速发展，为我们提供了前所未有的机遇，特别是对于前端开发领域，AI正以前所未有的速度改变着我们的工作方式和学习方式。AI赋能前端开发：个性化学习路径前端开发领域的技术栈庞大而复杂，涵盖HTML、CSS、JavaScript、各种框
    
                    
    • 
                    
  • 一款开源免费的数据可视化大屏 JimuBI，低代码与 AI 结合产品
                        

                        
    简介JimuBI是一个JAVA语言的低代码数据可视化大屏BI产品，将大屏、仪表盘、移动面板、图表或页面元素封装为基础组件，无需编写代码即可完成业务需求。这是JeecgBoot团队出品的另外一款报表产品，积木报表已经成为业内报表首先，预测该大屏即将覆盖全行业。酷炫大屏轻松设计，通过拖拽完成大屏设计，80多种组件及20多种边框装饰满足您的设计需求。智能仪表盘简单易用，拖拽式操作自由布局，页面自适应；支
    
                    
    • 
                    
  • Java灵魂拷问13个为什么，你都会哪些？
                        

                        
    大家好，我是V哥。今天看了阿里云开发者社区关于Java的灵魂拷问，一线大厂在用Java时，都会考虑哪些问题呢，对于工作多年，又没有大厂经历的小伙伴不妨看看，V哥总结的这13个为什么，你都会哪些？先赞后看，绝不摆烂。1.为什么禁止使用BigDecimal的equals方法做等值比较？BigDecimal的equals方法在等值比较时存在一些问题，通常不建议直接使用它来判断数值的相等性。下面是主要原因
    
                    
    • 
                    
  • 前后端分离VUE3+Springboot项目集成PageOffice核心代码
                        wqqqianqian
springbootjavapageofficevue在线编辑
                        
    后端Springboot项目在项目的pom.xml中通过下面的代码引入PageOffice依赖。pageoffice.jar已发布到Maven中央仓库，建议使用最新版本。com.zhuozhengsoftpageoffice6.3.3.1-javax在项目的启动类Application类中添加一项@Bean配置，此为PageOffice服务器端的必要配置，代码如下：@Value("${posysp
    
                    
    • 
                    
  • 前后端分离VUE+Springboot项目集成PageOffice核心代码
                        wqqqianqian
springbootvuepageoffice在线编辑
                        
    后端Springboot项目在项目的pom.xml中通过下面的代码引入PageOffice依赖。pageoffice.jar已发布到Maven中央仓库，建议使用最新版本。com.zhuozhengsoftpageoffice6.3.3.1-javax在项目的启动类Application类中添加一项@Bean配置，此为PageOffice服务器端的必要配置，代码如下：@Value("${posysp
    
                    
    • 
                    
  • Springboot毕设项目动物园售票管理系统96zau（java+VUE+Mybatis+Maven+Mysql）
                        韩元计算机毕设
mybatisjavaspringboot
                        
    项目运行环境配置：Jdk1.8+Tomcat8.5+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：Springboot+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也
    
                    
    • 
                    
  • 大厂面试系列：JVM中有哪些内存区域，分别都是用来干嘛的？
                        石杉的架构笔记
面试求职java面试jvm内存划分类加载
                        
    添加VX：ruyuan0220，回复：CSDN，领取更多精品学习资料！目录背景知识大厂面试背景引入到底什么是JVM的内存区域划分？存放类的方法区执行代码指令用的程序计数器Java虚拟机栈Java堆内存核心内存区域的全流程串讲其他内存区域本文小结背景知识我们先聊了一下相关的背景知识：JVM类加载这块的机制，简单介绍一下。大家需要搞明白的是，在什么情况下会触发类的加载？加载之后的验证、准备和解析分别是
    
                    
    • 
                    
  • 【2023华为OD-C卷-第三题-跳马】100%通过率（JavaScript&Java&Python&C++）
                        塔子哥学算法
java华为odc语言
                        
    本题已有网友报告代码100%通过率OJ&答疑服务购买任意专栏，即可私信博主，获取答疑/辅导服务题目描述马是象棋(包括中国象棋和国际象棋)中的棋子，走法是每步直一格再斜一格，即先横着或直着走一格，然后再斜着走一个对角线，可进可退，可越过河界，俗称马走“日”字。给定mmm行n
    
                    
    • 
                    
  • 【蓝桥杯】CB组国二攻略（省赛地点：广东）
                        好心的小明
蓝桥杯职场和发展
                        
    1.赛事介绍（针对深大）蓝桥杯是深大的二类竞赛，在计软国一二三保研分别加6，4，2分，国一国二能申请双创一等奖学金，国三能申请双创二等还是三等有点忘了（其实在申请的时候直接申请一等就行了，学院会根据你奖项的实际能申请的奖项给你调整的）。蓝桥杯有很多个组别，有软件组和硬件组，其中软件组针对不同编程语言分组，其中C/C++组人最多，竞争相对较大。JAVA组和Python组人相对较少，竞争可能稍微小一点
    
                    
    • 
                    
  • 华为OD机试E卷 - 跳马（Java & Python& JS & C++ & C ）
                        算法大师
最新华为OD机试java华为odpythonjavascriptc语言c++华为OD机试E卷
                        
    最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述输入m和n两个数，m和n表示一个m*n的棋盘。输入棋盘内的数据。棋盘中存在数字和"."两种字符，如果是数字表示该位置是一匹马，如果是"."表示该位置为空的，棋盘内的数字表示为该马能走的最大步数。例如棋盘内某个位置一个数字为k，表示该马只能移动1~k步的距离。棋盘内的马移动类似于中国象棋中的马移动，先在水平或者垂直方向上
    
                    
    • 
                    
  • 身份证实名认证功能的快速实现方法-Java接口集成
                        OCR_API
接口java开发语言
                        
    身份证实名认证接口是互联网在线平台为了确保用户身份真实性而采用的一种验证方式是，想要实现该功能，看似很难，其实有许多第三方服务商提供身份证实名认证接口，如：翔云API等，实时联网权威数据源，支持多并发核验身份证的真伪。集成API流程：对于有身份证实名认证功能需求的用户而言，注册账号，就会有唯一的key和secret，选择需要的产品id，然后根据自身需要的代码语言进行集成，以Java为例：packa
    
                    
    • 
                    
  • 2025java面试常见八股文整理
                        Java八股文面试
面试职场和发展javaspringbootjvmspringspringcloud
                        
    1.多线程编程下，怎么解决线程的数据安全问题？如果线程存在竞争临界资源，多线程访问下添加同步代码块synchronized解决，或者分布式排他锁进行临界资源控制。在分布式多线程环境下，线程的数据安全尽量不要产生连接资源，使用线程本地化ThreadLocal实现线程资源隔离。2.SpringIOC依赖注入怎么理解，spring有几种方式属性注入，setter构建pojo实体类和有参构造方法工厂方法注
    
                    
    • 
                    
  • 华为OD机试E卷 --跳马--24年OD统一考试（Java & JS & Python & C & C++）
                        飞码创造者
最新华为OD机试题库2024华为odjavajavascriptpythonc语言
                        
    文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c算法源码c++算法源码题目描述马是象棋（包括中国象棋和国际象棋）中的棋子，走法是每步直一格再斜一格，即先横着或者直者走一格，然后再斜着走一个对角线，可进可退，可越过河界，俗称"马走日"字。给定m行n列的棋盘（网格图），棋盘上只有棋子象棋中的棋子“马”，并且每个棋子有等级之分，等级为k的马可以跳1~k步（走
    
                    
    • 
                    
  • 【2023最新Java大厂面试题】——MyBatis面试题，看完拿捏面试官
                        Java凤梨
Java金三银四面试题mybatisjava面试
                        
    全套Java金三银四面试题持续更新可文末自取，建议关注收藏不然下次找不到哟~目录1、什么是Mybatis？2、Mybaits的优点：3、MyBatis框架的缺点：4、MyBatis框架适用场合：5、MyBatis与Hibernate有哪些不同？6、#{}和${}的区别是什么？7、当实体类中的属性名和表中的字段名不一样，怎么办？8、模糊查询like语句该怎么写?9、通常一个Xml映射文件，都会写一个
    
                    
    • 
                    
  • 使用arthas监控诊断java应用
                        handsomestWei
后端java开发语言
                        
    使用arthas监控诊断java应用简介arthas是阿里的一款线上监控诊断产品，通过全局视角实时查看应用load、内存、gc、线程的状态信息，并能在不修改应用代码的情况下，对业务问题进行诊断，包括查看方法调用的出入参、异常，监测方法执行耗时，类加载信息等，大大提升线上问题排查效率。安装使用参考常用命令使用dashboard查看当前应用整体信息dashboard命令详解包含有jvm信息，查看各代内
    
                    
    • 
                    
  • Java 网络编程（二）—— TCP流套接字编程
                        熵减玩家
JavaSE进阶网络javatcp
                        
    TCP和UDP的区别在传输层，TCP协议是有连接的，可靠传输，面向字节流，全双工而UDP协议是无连接的，不可靠传输，面向数据报，全双工有连接和无连接的区别是在进行网络通信的时候，通信双方有没有保存对端的地址信息，即假设A和B进行通信，A保存了B的地址信息，B也保存了A的地址信息，此时双方都知道和谁建立了连接，这就是有连接的通信，在之前的UDP数据报套接字编程中就提到过UDP是无连接的，所以在发送数
    
                    
    • 
                    
  • 深入理解 JavaScript 引擎与消息队列的底层原理
                        D.eL
javascript开发语言ecmascript
                        
    深入理解JavaScript引擎与消息队列的底层原理JavaScript是现代Web开发中最为重要的编程语言之一，它的运行和执行方式常常是开发者关注的重点。为了更好地理解JavaScript的执行过程，我们需要深入探索JavaScript引擎的工作原理，尤其是事件循环（EventLoop）、消息队列（MessageQueue）以及它们如何协同工作来处理异步任务。在这篇文章中，我们将深入分析Java
    
                    
    • 
                    
  • JavaScript详解十三 ——节点操作
                        遇见~未来
JavaScriptJavaScript详解javascript开发语言ecmascript
                        
    目录节点操作1、创建节点2、创建文本3、添加节点(先有父母才能生孩子)4、替换节点5、删除节点6、克隆节点7、创建节点另外几种方式（1）、element.innerHTML（2）、element.innerText（3）、document.write()（4）、insertAdjacentHTML()节点操作1、创建节点docment.createElement('节点')参数：标签名字符串这些元
    
                    
    • 
                    
  • linux制作自定义service服务单元
                        handsomestWei
后端linux后端
                        
    linux制作自定义service服务单元服务单元简介在Linux系统中，服务单元通常以.service后缀结尾，并存储在/etc/systemd/system目录下。服务单元文件定义了服务的启动顺序、依赖关系、执行命令等参数。使得系统管理员能够方便地启动、停止、重启和管理系统中的各种服务。java服务单元示例服务单元myJava.service文件示例。注意关闭标准输出，避免日志文件占用磁盘空间
    
                    
    • 
                                
  • html
                                    周华华
html
                                    
    js 
 1，数组的排列 
var arr=[1,4,234,43,52,]; 
 for(var x=0;x<arr.length;x++){ 
   for(var y=x-1;y<arr.length;y++){ 
     if(arr[x]<arr[y]){ 
    &
    
                                
    • 
                                
  • 【Struts2 四】Struts2拦截器
                                    bit1129
struts2拦截器
                                    
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 
  
Struts2中自定义拦截器的步骤是：
    
                                
    • 
                                
  • make:cc 命令未找到解决方法
                                    daizj
linux命令未知make cc
                                    
    安装rz sz程序时，报下面错误： 
  
[root@slave2 src]# make posix 
cc   -O -DPOSIX -DMD=2 rz.c -o rz 
make: cc：命令未找到 
make: *** [posix] 错误 127 
  
系统：centos 6.6 
环境：虚拟机 
  
错误原因：系统未安装gcc，这个是由于在安
    
                                
    • 
                                
  • Oracle之Job应用
                                    周凡杨
oracle job
                                    
      
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。 
  
一：查看相关job信息 
   1、相关视图  
 dba_jobs  
 all_jobs  
 user_jobs  
 dba_jobs_running 包含正在运行
    
                                
    • 
                                
  • 多线程机制
                                    朱辉辉33
多线程
                                    
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 
程序、进程和线程： 
 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
                                    老A不折腾
web报表finereportjava报表报表工具
                                    
    FineReport使用中遇到的常见报错及解决办法（一） 
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
  
1、address pool is full： 
含义：地址池满，连接数超过并发数上
    
                                
    • 
                                
  • mysql rpm安装后没有my.cnf
                                    林鹤霄
没有my.cnf
                                    
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    
                                
    • 
                                
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
                                    aigo
root
                                    
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ 
  
Step 4: Run ADB command from your PC 
  
On the PC, you need install Amazon Fire ADB driver and instal
    
                                
    • 
                                
  • javascript 中var提升的典型实例
                                    alxw4616
JavaScript
                                    
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
	console.log(myname); // undefined
	var myname = 'local';
	console.log(myname); // local
};
fn()

// 上述代码实际上等同于以下代码
m
    
                                
    • 
                                
  • 定时器和获取时间的使用
                                    百合不是茶
时间的转换定时器
                                    
    定时器:定时创建任务在游戏设计的时候用的比较多 
  Timer();定时器 
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。 
  
  
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    
                                
    • 
                                
  • JDK1.5 Queue
                                    bijian1013
javathreadjava多线程Queue
                                    
    JDK1.5 Queue 
LinkedList： 
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    
                                
    • 
                                
  • http认证原理和https
                                    bijian1013
httphttps
                                    
    一.基础介绍 
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。 
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    
                                
    • 
                                
  • 【Java范型五】范型继承
                                    bit1129
java
                                    
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 
  
package com.tom.lang.generics;

public abstract class SuperGenerics<T1, T2> {
    private T1 t1;
    private T2 t2;

    public abstract void doIt(T
    
                                
    • 
                                
  • 【Nginx六】nginx.conf常用指令(Directive)
                                    bit1129
Directive
                                    
    1. worker_processes    8; 
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 
  
nobody    53879 118449  0 Apr22 ?        00:26:15 nginx: worker process          
    
                                
    • 
                                
  • lua 遍历Header头部
                                    ronin47
lua header 遍历　
                                    
     
 local headers = ngx.req.get_headers()   
 ngx.say("headers begin", "<br/>")   
 ngx.say("Host : ", he
    
                                
    • 
                                
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
                                    bylijinnan
java
                                    
    
import java.util.Arrays;

public class MinSumASumB {

	/**
	 * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
	 * 
	 * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 
	 * 例如: 
	 * int[] a = {100,99,98,1,2,3
    
                                
    • 
                                
  • redis
                                    开窍的石头
redis
                                    
    在redis的redis.conf配置文件中找到# requirepass foobared 
把它替换成requirepass 12356789 后边的12356789就是你的密码 
 
打开redis客户端输入config get requirepass 
返回 
redis 127.0.0.1:6379> config get requirepass 
1) "require
    
                                
    • 
                                
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
                                    comsci
java语言
                                    
     
 
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情 
 
 
       
    
                                
    • 
                                
  • 安装ubuntu14.04登录后花屏了怎么办
                                    cuiyadll
ubuntu
                                    
    这个情况，一般属于显卡驱动问题。 
可以先尝试安装显卡的官方闭源驱动。 
按键盘三个键：CTRL + ALT  +  F1 
进入终端，输入用户名和密码登录终端： 
安装amd的显卡驱动       
sudo  
apt-get  
install  
fglrx       
安装nvidia显卡驱动       
sudo  
ap
    
                                
    • 
                                
  • SSL 与 数字证书 的基本概念和工作原理
                                    darrenzhu
加密ssl证书密钥签名
                                    
    SSL 与 数字证书 的基本概念和工作原理 

http://www.linuxde.net/2012/03/8301.html 
 
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 
 
 
 

http://www.ibm.com/developerworks/cn/webspher
    
                                
    • 
                                
  • Ubuntu设置ip的步骤
                                    dcj3sjt126com
ubuntu
                                    
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 
转载不是错： 
Ubuntu命令行修改网络配置方法 
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 
1. 以D
    
                                
    • 
                                
  • php包管理工具推荐
                                    dcj3sjt126com
PHPComposer
                                    
    http://www.phpcomposer.com/ 
       Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。  
中文文档  
入门指南  
下载  
安装包列表   
Composer 中国镜像      
    
                                
    • 
                                
  • Gson使用四（TypeAdapter）
                                    eksliang
jsongsonGson自定义转换器gsonTypeAdapter
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例 
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    
                                
    • 
                                
  • JQM控件之Navbar和Tabs
                                    gundumw100
htmlxmlcss
                                    
    在JQM中使用导航栏Navbar是简单的。 
 
只需要将data-role="navbar"赋给div即可： 
 

<div data-role="navbar">
    <ul>
        <li><a href="#" class="ui-btn-active&qu
    
                                
    • 
                                
  • 利用归并排序算法对大文件进行排序
                                    iwindyforest
java归并排序大文件分治法Merge sort
                                    
      
归并排序算法介绍，请参照Wikipeida 
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 
基本思想： 
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 
低于限制行数的子文件直接排序 
两个排序好的子文件归并到父文件 
直到最后所有排序好的父文件归并到输入
    
                                
    • 
                                
  • iOS UIWebView URL拦截
                                    啸笑天
UIWebView
                                    
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    
                                
    • 
                                
  • 索引的碎片整理SQL语句
                                    macroli
sql
                                    
    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    
                                
    • 
                                
  • Angularjs同步操作http请求with $promise
                                    qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象
                                    
    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
      var deferred = $q.defer();
      AccountService.getProfile().then(function(res) {
  
    
                                
    • 
                                
  • hibernate联合查询问题
                                    sxj19881213
sqlHibernateHQL联合查询
                                    
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 
  
1 几个常识： 
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。 
 （2）hql的默认查询策略，在进行联合查询时，会产
    
                                
    • 
                                
  • struts2.xml
                                    wuai
struts
                                    
    <?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE struts PUBLIC 
 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 
 "http://struts.apache
    
                                
    •