suqinyi
suqinyi

多线程线程池详解、 线程异步编排和线程串行化

多线程进阶

文章目录

  • 多线程进阶
  • 前言
  • 一、创建多线程的4种方式（回顾）
    • 1.1、创建线程
    • 1.2、区别
    • 1.3 总结
  • 二、线程池创建和说明
    • 1、自定义线程池
      • 1.1、7大参数说明
      • 1.2、自定义创建
      • 1.3、工作顺序
      • 1.4、案例思考
    • 2、Executors创建功能性线程池
      • 2.1、常见的四种功能性线程池
      • 2.2、创建定长线程池
      • 2.3、为什么使用线程池
  • 三、CompletableFuture异步编排
    • 1.1、CompletableFuture介绍
    • 1.2、常使用的2种创建方式
      • 1.2.1、runAsync没有返回值
      • 1.2.2、supplyAsync有返回值
    • 1.3、 whenComplete 和 handle
      • 1.3.1、 whenComplete + supplyAsync
      • 1.3.2、 handle + supplyAsync（推荐）
  • 四、线程串行化
    • 1、线程串行化的方法
      • 1.1、thenRun （无返回值）
      • 1.2、thenAcceptAsync（获取上个线程的结果，本身无返回值）
      • 1.3、thenAcceptAsync（获取上个线程的结果，自己有返回值）
    • 2、两任务组合 - 都要完成
      • 2.1、runAfterBothAsync(无法感知前面俩个的结果，自己没有返回值)
      • 2.2、runAfterBothAsync(能感知前面的结果，自己没有返回值)
      • 2.3、 thenCombineAsync（能感知前面的结果，自己有返回值）
    • 3、两任务组合 ，任意一个完成。执行任务3
      • 3.1、runAfterEitherAsync
      • 3.2、acceptEitherAsync
      • 3.3、applyToEitherAsync
  • 五、多任务组合（allOf和anyOf）

前言

多线程，可以先看下小编总结的多线程（一）基础篇==>文章入口

一、创建多线程的4种方式（回顾）

1.1、创建线程

  1. 继承 Thread
  2. 实现 Runnable 接口
  3. 实现 Callable 接口 + FutureTask
  4. 线程池一: 自定义方式
  5. 线程池二: Executors的常见4种功能性线程池创建
import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //当前系统中只有一俩个池子。每个异步任务，提交给线程池他自己执行就行
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");

        //方式1继承Thread  启动线程
        Thread01 thread = new Thread01();
        thread.start();
        System.out.println("============================");

        //方式2实现Runnable接口 启动线程
        Runnable01 runnable01 = new Runnable01();
        new Thread(runnable01).start();
        System.out.println("============================");

        //方式3、实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常） 启动线程
        // 注：FutureTask里面也能放Runnable
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        Integer result = futureTask.get();//阻塞等待--等待整个线程执行完成，获取返回结果
        System.out.println("最后的返回结果：" + result);
        System.out.println("============================");

        //方式4 Executors创建线程池执行 Runnable01任务
        execute.execute(new Runnable01());
        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("继承Thread...运行结果:" + i);
        }
    }

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

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

    public static class Runnable04 implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("线程池放Runnable04...运行结果:" + i);
        }
    }

}

运行结果：

main...start...
============================
当前线程：12
继承Thread...运行结果:5
============================
当前线程：13
实现Runnable接口...运行结果:5
当前线程：14
实现 Callable 接口 + FutureTask...运行结果:5
最后的返回结果：5
============================
main...end...
当前线程：15
实现Runnable接口...运行结果:5

1.2、区别

方式1、2 不能得到返回值。3可以获取返回值
方式1、2、3 都不能控制资源
方式4 可以控制资源，性能稳定。

1.3 总结

在业务场景，以上3种方式启动线程都不使用。会导致资源耗尽。

将所有多线程异步任务都交给线程池执行

二、线程池创建和说明

1、自定义线程池

1.1、7大参数说明

  1. int corePoolSize:核心线程数
  2. int maximumPoolSize:最大线程数量。控制资源
  3. long keepAliveTime: 存活时间
  4. TimeUnit unit: 时间单位
  5. BlockingQueue workQueue: 阻塞队列。
  6. ThreadFactory threadFactory: 线程的创建工厂
  7. RejectedExecutionHandler handler: 拒绝策略
线程池的7大参数：
     01、int corePoolSize: 核心线程数(一直存在,除非allowCoreThreadTimeOut)。
           线程池，创建好以后就准备就绪的线程数量，就等待接收异步任务来执行
           例如：corePoolSize:[5]  等于 5个 Thread thread = new Thread()
       
     02、int maximumPoolSize: 最大线程数量。控制资源
         
     03、long keepAliveTime: 存活时间。如果当前的线程数量大于核心数量（corePoolSize）
           释放空闲的线程（maximumPoolSize - corePoolSize）。
           只要线程空闲大于指定的keepAliveTime，就会释放
         
     04、TimeUnit unit: 时间单位
         
     05、BlockingQueue<Runnable> workQueue: 阻塞队列。
            如果任务有很多，就会将目前多的任务放在队列里面
            只要有线程空闲，就会去队列里面取出新的任务执行
         
     06、ThreadFactory threadFactory: 线程的创建工厂
         
     07、RejectedExecutionHandler handler: 拒绝策略
           如果队列满了，按照我们指定的拒绝策略拒绝执行任务

1.2、自定义创建

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {


    public static void main(String[] args) throws Exception {
      /**
        *   new LinkedBlockingDeque<>()：默认是Integer的最大值。容易导致内存不够。
        *   要指定数量，例如： new LinkedBlockingDeque<>(10000)
        */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        executor.execute(new Runnable05());
    }

    public static class Runnable05 implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("线程池放Runnable05...运行结果:" + i);
        }
    }
}

运行结果：
多线程线程池详解、 线程异步编排和线程串行化_第1张图片

1.3、工作顺序

  1. 线程池创建，准备好 core 数量的核心线程，准备接受任务
  2. core 满了，就将再进来的任务放入阻塞队列中。空闲的 core 就会自己去阻塞队列获取任务执行
  3. 阻塞队列满了，就直接开新线程执行，最大只能开到 max 指定的数量
  4. max 满了，就会使用 RejectedExecutionHandler handler 指定的拒绝策略进行处理
  5. max都执行完了，有很多空闲。在执行的时间keepAliveTime以后，释放Max-core这些线程。最终保持到 core 大小
  6. 所有的线程创建都是由指定的 factory 创建的。

1.4、案例思考

一个线程池 core 7； max 20 ，queue：50，100 并发进来怎么分配的？

先有 7 个能直接得到执行，接下来 50 个进入队列排队，在多开 13 个继续执行。
现在 70 个被安排上了。剩下 30 个默认拒绝策略


如果不想抛弃还要执行。使用CallerRunsPolicy策略。会同步执行
或者将最老的，一直不执行的丢弃

2、Executors创建功能性线程池

2.1、常见的四种功能性线程池

  1. Executors.newCachedThreadPool() 可缓存线程池（core是0，所有都可以回收）
  2. Executors.newFixedThreadPool() 固定大小的线程池（core=max，都不可以回收）
  3. Executors.newScheduledThreadPool() 定时任务的线程池
  4. Executors.newSingleThreadExecutor() 单线程的线程池，后台从队列里面一个一个拿出来执行

单线程的线程池应用说明：
应用场景：分布式的情况下，保证双写一致的情况，需要将同样的业务留给同一台服务器或者线程来执行处理

2.2、创建定长线程池

  //大小为10
  ExecutorService execute = Executors.newFixedThreadPool(10);
  //执行
  execute.execute(new Runnable01());//看创建多线程的4种方式（回顾）里面的第4种

2.3、为什么使用线程池

  1. 降低资源的消耗==>通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
  2. 提高响应速度==>因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行
  3. 提高线程的可管理性==>线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

三、CompletableFuture异步编排

1.1、CompletableFuture介绍

在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的
Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以
通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。

1.2、常使用的2种创建方式

  1. CompletableFuture.runAsync
  2. CompletableFuture.supplyAsync
  3. 说明：xxxAsync表示异步，没有Async表示同步

1.2.1、runAsync没有返回值

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        //可以传入自定义的线程池，否则就用默认的线程池；
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("main...start...");
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
        }, execute);
        System.out.println("main...end...");
    }
}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第2张图片

1.2.2、supplyAsync有返回值

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("main...start...");
        //可以传入自定义的线程池，否则就用默认的线程池；
        //第二种：supplyAsync的whenComplete
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, execute);
        Integer res = future.get();
        System.out.println("返回值:"+res);

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

}

运行结果：
多线程线程池详解、 线程异步编排和线程串行化_第3张图片

1.3、 whenComplete 和 handle

  1. 方法执行完成后的感知==>whenComplete
  2. 方法执行完成后的处理==>handle

1.3.1、 whenComplete + supplyAsync

只能感知异常，无法修改返回的数据

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("main...start...");
                CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
//            int i = 10 / 0;//制造异常
            System.out.println("运行结果:" + i);
            return i;
        }, execute).whenComplete((result,exception)->{
            //【whenComplete缺点只能感知】
            //感知异常,但是没法修改返回数据
            System.out.println("异步任务执行完成了。。。结果是:"+result+" "+"异常是:"+exception);
        }).exceptionally(throwable -> {
            //可以感知异常，同事返回默认值
            return 10;//出现异常返回10
        });

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

}

结果：
多线程线程池详解、 线程异步编排和线程串行化_第4张图片

1.3.2、 handle + supplyAsync（推荐）

处理完在返回

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("main...start...");
        //第二种：supplyAsync的handle
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, execute).handle((result, exception) -> {
            if (result != null) {
                return result * 50;
            }
            if (exception != null) {
                return 0;
            }
            return 0;
        });
        Integer returnResult = future.get();
        System.out.println("返回的结果："+returnResult);

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

}

运行结果：
多线程线程池详解、 线程异步编排和线程串行化_第5张图片

四、线程串行化

  1. thenRun 不能获取到上一步的执行结果，无返回值
  2. thenAcceptAsync 能接收上一步结果，但是无返回值
  3. thenApplyAsync 能接收上一步结果，有返回值
thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值

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

thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行thenRun 的后续操作带有 Async 默认是异步执行的。 同之前。以上都要前置任务成功完成。

1、线程串行化的方法

1.1、thenRun （无返回值）

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        //thenRunAsync
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, execute).thenRunAsync(() -> {
            //模拟第二个线程任务
            System.out.println("任务2启动了。。。模拟第二个线程任务");
        }, execute);
        
        System.out.println("============main...start...===============");
    }

}

1.2、thenAcceptAsync（获取上个线程的结果，本身无返回值）

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        //thenAcceptAsync
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, execute).thenAcceptAsync(result -> {
            //模拟第二个线程任务，拿到上一个线程的处理结果，继续线程操作
            System.out.println("任务2启动了《模拟第二个线程任务，拿到上一个线程的处理结果，继续线程操作》..上一次的结果：" + result);
        }, execute);

        System.out.println("============main...start...===============");
    }

}

1.3、thenAcceptAsync（获取上个线程的结果，自己有返回值）

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1=运行结果:" + i);
            return i;
        }, execute).thenApplyAsync((result) -> {
            System.out.println("任务2启动了《模拟第二个线程任务，拿到上一个线程的处理结果，继续线程操作》..上一次的结果：" + result);
            return "Hello " + result;
        }, execute);
        String s = future.get();
        System.out.println("有返回值！！！==>最后的返回值:"+s);

        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第6张图片

2、两任务组合 - 都要完成

  • thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
  • thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。
  • runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，
    处理该任务

2.1、runAfterBothAsync(无法感知前面俩个的结果，自己没有返回值)

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 俩个都完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

        //第一种 runAfterBothAsync无法感知前面俩个的结果
        future01.runAfterBothAsync(future02,()->{
            //线程1组合线程2，都完成以后开始任务3
            System.out.println("任务3开始");
        },execute);

//        //第二种 thenAcceptBothAsync能感知前面的结果
//        future01.thenAcceptBothAsync(future02,(f1,f2)->{
//            System.out.println("任务3开始");
//            System.out.println("任务1的返回值："+f1);
//            System.out.println("任务2的返回值："+f2);
//        },execute);


//        //第三种 thenCombineAsync能感知前面的结果，自己有返回值
//        CompletableFuture future03 = future01.thenCombineAsync(future02, (f1, f2) -> {
//            System.out.println("任务3开始");
//            return f1 + ":" + f2 + "我是任务3的返回";
//        }, execute);
//        String s = future03.get();
//        System.out.println(s);


        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第7张图片

2.2、runAfterBothAsync(能感知前面的结果，自己没有返回值)


import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 俩个都完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

//        //第一种 runAfterBothAsync无法感知前面俩个的结果
//        future01.runAfterBothAsync(future02,()->{
//            //线程1组合线程2，都完成以后开始任务3
//            System.out.println("任务3开始");
//        },execute);

        //第二种 thenAcceptBothAsync能感知前面的结果
        future01.thenAcceptBothAsync(future02,(f1,f2)->{
            System.out.println("任务3开始");
            System.out.println("任务1的返回值："+f1);
            System.out.println("任务2的返回值："+f2);
        },execute);

//        //第三种 thenCombineAsync能感知前面的结果，自己有返回值
//        CompletableFuture future03 = future01.thenCombineAsync(future02, (f1, f2) -> {
//            System.out.println("任务3开始");
//            return f1 + ":" + f2 + "我是任务3的返回";
//        }, execute);
//        String s = future03.get();
//        System.out.println(s);


        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第8张图片

2.3、 thenCombineAsync（能感知前面的结果，自己有返回值）

package com.atguigu.gulimall.product;

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 俩个都完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

//        //第一种 runAfterBothAsync无法感知前面俩个的结果
//        future01.runAfterBothAsync(future02,()->{
//            //线程1组合线程2，都完成以后开始任务3
//            System.out.println("任务3开始");
//        },execute);

//        //第二种 thenAcceptBothAsync能感知前面的结果
//        future01.thenAcceptBothAsync(future02,(f1,f2)->{
//            System.out.println("任务3开始");
//            System.out.println("任务1的返回值："+f1);
//            System.out.println("任务2的返回值："+f2);
//        },execute);

        //第三种 thenCombineAsync能感知前面的结果，自己有返回值
        CompletableFuture<String> future03 = future01.thenCombineAsync(future02, (f1, f2) -> {
            System.out.println("任务3开始");
            return f1 + ":" + f2 + "我是任务3的返回";
        }, execute);
        String s = future03.get();
        System.out.println(s);


        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第9张图片

3、两任务组合 ，任意一个完成。执行任务3

俩个任务，只要有一个完成，就执行任务3

  1. runAfterEitherAsync:不感知结果，自己也无返回值
  2. acceptEitherAsync：感知结果，自己无返回值[注：任务1和任务2的返回值类型必须一致]
  3. applyToEitherAsync: 感知结果，自己有返回值

3.1、runAfterEitherAsync

package com.atguigu.gulimall.product;

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 来个任务，任意一个完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

        //第一种 runAfterEitherAsync
        future01.runAfterEitherAsync(future02,()->{
            System.out.println("任务3开始");
        },execute);

//        //第二种 acceptEitherAsync==>[任务1和任务2的返回值类型必须一致]
//        future01.acceptEitherAsync(future02,(res)->{
//            System.out.println("任务3开始..."+"之前的线程1的结果："+res);
//        },execute);
//
//        //第三种 applyToEitherAsync
//        CompletableFuture future03 = future01.applyToEitherAsync(future02, (res) -> {
//            System.out.println("任务3开始..." + "之前的线程1的结果：" + res);
//            return res.toString() + "-->hello";
//        }, execute);
//        String f3 = future03.get();
//        System.out.println("f3:"+f3);

        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第10张图片

3.2、acceptEitherAsync

package com.atguigu.gulimall.product;

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 来个任务，任意一个完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

//        //第一种 runAfterEitherAsync
//        future01.runAfterEitherAsync(future02,()->{
//            System.out.println("任务3开始");
//        },execute);

        //第二种 acceptEitherAsync==>[任务1和任务2的返回值类型必须一致]
        future01.acceptEitherAsync(future02,(res)->{
            System.out.println("任务3开始..."+"之前的线程1的结果："+res);
        },execute);

//        //第三种 applyToEitherAsync
//        CompletableFuture future03 = future01.applyToEitherAsync(future02, (res) -> {
//            System.out.println("任务3开始..." + "之前的线程1的结果：" + res);
//            return res.toString() + "-->hello";
//        }, execute);
//        String f3 = future03.get();
//        System.out.println("f3:"+f3);

        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第11张图片

3.3、applyToEitherAsync

package com.atguigu.gulimall.product;

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 来个任务，任意一个完成
         */
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1结束");
            return i;
        }, execute);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束");
            return "Hello";
        }, execute);

//        //第一种 runAfterEitherAsync
//        future01.runAfterEitherAsync(future02,()->{
//            System.out.println("任务3开始");
//        },execute);

//        //第二种 acceptEitherAsync==>[任务1和任务2的返回值类型必须一致]
//        future01.acceptEitherAsync(future02,(res)->{
//            System.out.println("任务3开始..."+"之前的线程1的结果："+res);
//        },execute);

//        //第三种 applyToEitherAsync
        CompletableFuture<String> future03 = future01.applyToEitherAsync(future02, (res) -> {
            System.out.println("任务3开始..." + "之前的线程1的结果：" + res);
            return res.toString() + "-->hello";
        }, execute);
        String f3 = future03.get();
        System.out.println("f3:"+f3);

        System.out.println("============main...start...===============");
    }

}

效果：
多线程线程池详解、 线程异步编排和线程串行化_第12张图片

五、多任务组合（allOf和anyOf）

  1. allOf：等待所有任务完成
  2. anyOf：只要有一个任务完成
  3. 注：anyOf就是有一个完成就可以返回。
package com.atguigu.gulimall.product;

import java.util.concurrent.*;

/**
 * @author suqinyi
 * @Date 2021/8/22
 */
public class Thread4Test {

    //自定义的线程池
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        System.out.println("===========main...start...===============");

        /**
         * 多任务组合
         */
        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("查询物品的图片信息1");
            return "hello.jpg";
        },execute);
        
        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("查询物品的属性2");
            return "蓝色+256G";
        },execute);
        
        CompletableFuture<String> futureDesc= CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("查询物品的介绍3");
            return "介绍=价格998";
        },execute);

        //1、allOf
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
        //allOf.join();//插队---get或者join都行
        allOf.get();//等待所有结果完成--->最后的一句话最后打印.阻塞住==>就是这个 System.out.println("============main...start...===============");
        System.out.println("futureImg:"+futureImg.get()+"..."+"futureAttr:"+futureAttr.get()+"..."+"futureDesc:"+futureDesc.get());

//        //2、anyOf
//        CompletableFuture anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
//        Object o = anyOf.get();
//        System.out.println("anyOf:"+o);


        System.out.println("============main...start...===============");
    }

}

 
  
allOf的效果：
 多线程线程池详解、 线程异步编排和线程串行化_第13张图片
 anyOf的效果：
 多线程线程池详解、 线程异步编排和线程串行化_第14张图片
 上一篇：java基础总结之多线程（一）
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(多线程,线程池,多线程,串行化,多线程异步编排,Java基础)

        

            

                
    
                    
  • ios GCD
                        _Waiting_

                        
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
    
                    
    • 
                    
  • 多线程之——ExecutorCompletionService
                        阿福德

                        
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
    
                    
    • 
                    
  • python多线程程序设计 之一
                        IT_Beijing_BIT
#Python程序设计语言python
                        
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • 06选课支付模块之基于消息队列发送支付通知消息
                        echo 云清
学成在线javarabbitmq消息队列支付通知学成在线
                        
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    
                    
    • 
                    
  • Python多线程实现大规模数据集高效转移
                        sand&wich
网络python服务器
                        
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Python实现下载当前年份的谷歌影像
                        sand&wich
python开发语言
                        
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流
                        图像处理大大大大大牛啊
opencv实战代码讲解视觉图像项目windowspythonopencv
                        
    windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 【JS】前端文件读取FileReader操作总结
                        程序员-张师傅
前端前端javascript开发语言
                        
    前端文件读取FileReader操作总结FileReader是JavaScript中的一个WebAPI，它允许web应用程序异步读取用户计算机上的文件（或原始数据缓冲区）的内容，例如读取文件以获取其内容，并在不将文件发送到服务器的情况下在客户端使用它。这对于处理图片、文本文件等非常有用，尤其是当你想要在用户界面中即时显示文件内容或进行文件预览时。创建FileReader对象首先，你需要创建一个Fi
    
                    
    • 
                    
  • C# 开发教程-入门基础
                        天马3798
教程系列整理c#开发语言
                        
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
    
                    
    • 
                    
  • [面试高频问题]关于多线程的单例模式
                        朱玥玥要每天学习
java单例模式开发语言
                        
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • 基于flask做大模型SSE输出
                        Mark_Aussie
nlpflaskpython后端
                        
    默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
    
                    
    • 
                    
  • 为什么Node.js不适合CPU密集型应用？
                        weixin_54503231
node.js
                        
    Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
    
                    
    • 
                    
  • rabbitmq
                        楚楚ccc
Java系列rabbitmq分布式
                        
    1.消息服务概述、rabbitmq核心概念消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(messagebroker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(pu
    
                    
    • 
                    
  • 使用 RabbitMQ 实现秒杀订单系统的异步消息处理
                        c137范特西
rabbitmq分布式
                        
    使用RabbitMQ实现秒杀订单系统的异步消息处理在秒杀系统中，如何确保高并发环境下的订单处理稳定高效是个很大的挑战。为了解决这个问题，我们通常会引入消息队列，通过异步处理来削峰填谷。这篇文章将详细讲解如何使用RabbitMQ来设计一个秒杀订单系统的异步消息处理流程，重点是如何使用交换机（Exchange）、队列（Queue）、路由键（RoutingKey）以及死信队列（DeadLetterQue
    
                    
    • 
                    
  • （k8s）Kubernetes 从0到1容器编排之旅
                        道不贱卖，法不轻传
kubernetskubernetes容器云原生
                        
    一、引言在当今数字化的浪潮中，Kubernetes如同一艘强大的航船，引领着容器化应用的部署与管理。它以其卓越的灵活性、可扩展性和可靠性，成为众多企业和开发者的首选。然而，要真正发挥Kubernetes的强大威力，仅仅掌握基本操作是远远不够的。本文将带你深入探索Kubernetes使用过程中的奇技妙法，为你开启一段优雅的容器编排之旅。二、高级资源管理之精妙艺术1.资源配额与限制：雕琢资源之美•Ku
    
                    
    • 
                    
  • springboot与日志
                        最后的夏t

                        
    日志1、日志框架小张；开发一个大型系统；1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar；3、高大上的几个功能？异步模式？自动归档？xxxx？zhanglogging-good.jar？4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-p
    
                    
    • 
                    
  • PCL 点云视窗类CloudViewer
                        LeonDL168
PCL算法计算机视觉人工智能视觉检测图像处理
                        
    点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
    
                    
    • 
                    
  • 大胆猜！主持人大赛第二阶段，谁最有望夺冠
                        童说家

                        
    看完第六期又再次刷新了小编的认知，简直太过瘾了。选手们的实力就不用说了，光出题嘉宾的阵容就够人惊叹了，甚至连央视boys在这一期都合体了。好不容易熬到了上周六，可是第七期节目却因为节目编排的原因停更了，小编只好再刷遍第六期过足眼瘾啦！来源于主持人大赛第二赛段的“经典节目实战”难度提高了不少，央视的十档经典节目在场上被参赛选手重新演绎，不仅考验选手对相关内容的把握能力，对事物的分析、提炼和概括表述能
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    
                    
    • 
                    
  • 七律 秋运会
                        清源之流

                        
    图片发自App清晨列队齐征战，飒爽英姿众口夸。笑靥如花扬梦想，流年若水眷芳华。衣衫素雅成旗帜，树木青葱待彩霞。舞蹈编排风采展，凝心聚智闯天涯。图片发自App图片发自App
    
                    
    • 
                    
  • java ajax_Java Ajax入门
                        孤独患喆
javaajax
                        
    接下来整理一下Ajax相关的内容，AJAX(asynchronousjsandxml)，即异步的JavaScript和xml，它的主要作用就是让页面不必等待服务器返回整个页面信息，而可以通过异步的方式给服务器发送数据和获取数据，对页面进行局部刷新，是一种提高用户体验的技术。同步和异步同步和异步的主要区别如下；(1)同步：一个响应结束后才能发送下一个请求，页面在请求期间不能做其他事情。(2)异步：不
    
                    
    • 
                    
  • html加载界面发送ajax请求
                        足球数据分析
htmlajax前端
                        
    html加载界面发送ajax请求makeAjaxRequest();functionmakeAjaxRequest(){varxhr=newXMLHttpRequest();//创建一个新的XMLHttpRequest对象xhr.open('GET','yourUrlPath',true);//配置请求，设置请求类型、URL和是否异步xhr.send();//发送请求}
    
                    
    • 
                                
  • 统一思想认识
                                    永夜-极光
思想
                                    
    1.统一思想认识的基础,才能有的放矢 
 原因: 
   总有一种描述事物的方式最贴近本质,最容易让人理解. 
   如何让教育更轻松,在于找到最适合学生的方式. 
         难点在于,如何模拟对方的思维基础选择合适的方式.   &
    
                                
    • 
                                
  • Joda Time使用笔记
                                    bylijinnan
javajoda time
                                    
    Joda Time的介绍可以参考这篇文章： 
 
http://www.ibm.com/developerworks/cn/java/j-jodatime.html 
 
工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： 
    
 
   /**
     * DateTime变化（增减）
     */
    @Tes
    
                                
    • 
                                
  • FileUtils API
                                    eksliang
FileUtilsFileUtils API
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • 各种新兴技术
                                    不懂事的小屁孩
技术
                                    
    1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。 
 
现在构建系统常用到maven工具，现在有更容易上手的gradle， 
搭建java环境:
http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 
搭建android环境：
http://m
    
                                
    • 
                                
  • tomcat6的https双向认证
                                    酷的飞上天空
tomcat6
                                    
    1.生成服务器端证书 
  
keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
    
                                
    • 
                                
  • 托管虚拟桌面市场势不可挡
                                    蓝儿唯美

                                    
    用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。 
在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 
MSP的利润空间将根据其参与的程度而有所不同，Din说。 
“我们有一些合作伙伴负责将我们推荐给客户作为个
    
                                
    • 
                                
  • spring学习——xml文件的配置
                                    a-john
spring
                                    
    在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.or
    
                                
    • 
                                
  • HDU 4342 History repeat itself 模拟
                                    aijuans
模拟
                                    
    来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 
题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。 
思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
    
                                
    • 
                                
  • java中最常用jar包的用途
                                    asia007
java
                                    
    java中最常用jar包的用途 
jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法.  w
    
                                
    • 
                                
  • ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法
                                    百合不是茶
jsjson编码返回异常
                                    
    一:ajax获取自定义Struts框架中的json编码  出现以下 问题:     
  
1,强制flush输出  json编码打印在首页 
2, 不强制flush js会解析json 打印出来的是错误的jsp页面   却没有跳转到错误页面 
3,  ajax中的dataType的json 改为text 会
    
                                
    • 
                                
  • JUnit使用的设计模式
                                    bijian1013
java设计模式JUnit
                                    
    JUnit源代码涉及使用了大量设计模式 
1、模板方法模式（Template Method） 
        定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。 
  
    
                                
    • 
                                
  • Linux常用命令（摘录）
                                    sunjing
crondchkconfig
                                    
    chkconfig --list   查看linux所有服务 
chkconfig --add servicename 添加linux服务 
netstat -apn | grep 8080  查看端口占用 
env 查看所有环境变量 
echo $JAVA_HOME 查看JAVA_HOME环境变量 
  
安装编译器 
yum install -y gcc
    
                                
    • 
                                
  • 【Hadoop一】Hadoop伪集群环境搭建
                                    bit1129
hadoop
                                    
     结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。   &nb
    
                                
    • 
                                
  • Anychart图表系列五之事件监听
                                    白糖_
chart
                                    
    创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。 
以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： 
<script>
//创建AnyChart
var chart = new AnyChart();
//添加钻取操作&quo
    
                                
    • 
                                
  • Web前端相关段子
                                    braveCS
web前端
                                    
    Web标准：结构、样式和行为分离 
  
使用语义化标签 
0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 
1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
    
                                
    • 
                                
  • 编程之美-24点游戏
                                    bylijinnan
编程之美
                                    
    

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;


public class PointGame {

	/**编程之美 
    
                                
    • 
                                
  • 主页面子页面传值总结
                                    chengxuyuancsdn
总结
                                    
    1、showModalDialog
returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值
主界面
 var sonValue=window.showModalDialog("son.jsp");
子界面
  window.retu
    
                                
    • 
                                
  • [网络与经济]互联网+的含义
                                    comsci
互联网+
                                    
     
      互联网+后面是一个人的名字 = 网络控制系统 
 
      互联网+你的名字 =  网络个人数据库 
 
      每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
    
                                
    • 
                                
  • oracle 创建视图 with check option
                                    daizj
视图vieworalce
                                    
    我们来看下面的例子： 
create or replace view testview 
as 
select empno,ename from emp where ename like ‘M%’ 
with check option; 
 
这里我们创建了一个视图，并使用了with check option来限制了视图。 然后我们来看一下视图包含的结果： 
select * from testv
    
                                
    • 
                                
  • ToastPlugin插件在cordova3.3下使用
                                    dibov
Cordova
                                    
        自己开发的Todos应用，想实现“ 
再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。      
    ToastPlugin.java        
package&nbs
    
                                
    • 
                                
  • C语言22个系统函数
                                    dcj3sjt126com
cfunction
                                    
    C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和 以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
    
                                
    • 
                                
  • 开发一个类的流程
                                    dcj3sjt126com
开发
                                    
    本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。 
  
以下是开发流程： 
1. 明确类的功能，抽象出类的大概结构 
2. 初步设想类的接口 
3. 类名设计（驼峰式命名） 
4. 属性设置(权限设置) 
判断某些变量是否有必要作为成员属
    
                                
    • 
                                
  • java 并发
                                    shuizhaosi888
java 并发
                                    
    能够写出高伸缩性的并发是一门艺术 
  
在JAVA SE5中新增了3个包  
 
 java.util.concurrent 
 java.util.concurrent.atomic 
 java.util.concurrent.locks 
  
在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。 
    
                                
    • 
                                
  • Spring Security（11）——匿名认证
                                    234390216
Spring SecurityROLE_ANNOYMOUS匿名
                                    
    匿名认证 
目录 
1.1     配置 
1.2     AuthenticationTrustResolver 
  
       对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
    
                                
    • 
                                
  • NODEJS项目实践0.2[ express,ajax通信...]
                                    逐行分析JS源代码
Ajaxnodejsexpress
                                    
      
一、前言 
        通过上节学习，我们已经        ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务 及 mongodb的存取，但写着写着，web端就
    
                                
    • 
                                
  • 在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值
                                    lhbthanks
javahtmlstrutscheckbox
                                    
    第一种方法：获取结果String类型 
在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。 
 
所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。 
以下是实现的代码： 
 前台 HTML 代码： 
 
 
 
    
                                
    • 
                                
  • 003.Kafka基本概念
                                    nweiren
hadoopkafka
                                    
    Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。   Topic：               消息源（Message）的分类。   Partition：               Topic物理上的分组，一
    
                                
    • 
                                
  • Linux环境下安装JDK
                                    roadrunners
jdklinux
                                    
    1、准备工作 
创建JDK的安装目录： 
mkdir -p /usr/java/ 
  
下载JDK，找到适合自己系统的JDK版本进行下载： 
http://www.oracle.com/technetwork/java/javase/downloads/index.html 
  
把JDK安装包下载到/usr/java/目录，然后进行解压： 
tar -zxvf jre-7
    
                                
    • 
                                
  • Linux忘记root密码的解决思路
                                    tomcat_oracle
linux
                                    
    1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码   　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断.   　　3: grub启动菜单中加入 single以单用户进入系统.   　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除   　　例如:   　　ro
    
                                
    • 
                                
  • 跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现
                                    xueyou
jsonpjquery框架UIhtml5
                                    
    postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p
    
                                
    •