我们常用ThreadPoolExecutor提供的线程池服务，springboot框架提供了@Async注解，帮助我们更方便的将业务逻辑提交到线程池中异步执行，今天我们就来实战体验这个线程池服务；

本文地址：http://blog.csdn.net/boling_cavalry/article/details/79120268

实战环境

  1. windowns10；
  2. jdk1.8；
  3. springboot 1.5.9.RELEASE；
  4. 开发工具：IntelliJ IDEA；

实战源码

本次实战的源码可以在我的GitHub下载，地址：git@github.com:zq2599/blog_demos.git，项目主页：https://github.com/zq2599/blog_demos

这里面有多个工程，本次用到的工程为threadpooldemoserver，如下图红框所示： 

实战步骤梳理

本次实战的步骤如下： 
1. 创建springboot工程； 
2. 创建Service层的接口和实现； 
3. 创建controller，开发一个http服务接口，里面会调用service层的服务； 
4. 创建线程池的配置； 
5. 将Service层的服务异步化，这样每次调用都会都被提交到线程池异步执行； 
6. 扩展ThreadPoolTaskExecutor，在提交任务到线程池的时候可以观察到当前线程池的情况；

创建springboot工程

用IntelliJ IDEA创建一个springboot的web工程threadpooldemoserver，pom.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bolingcavalry</groupId>

    <artifactId>threadpooldemoserver</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>threadpooldemoserver</name>

    <description>Demo project for Spring Boot</description>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.9.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

创建Service层的接口和实现

创建一个service层的接口AsyncService，如下：

public interface AsyncService {

    /**

     * 执行异步任务

     */

    void executeAsync();

}

对应的AsyncServiceImpl，实现如下：

@Service

public class AsyncServiceImpl implements AsyncService {

    private static final Logger logger = LoggerFactory.getLogger(AsyncServiceImpl.class);

    @Override

    public void executeAsync() {

        logger.info("start executeAsync");

        try{

            Thread.sleep(1000);

        }catch(Exception e){

            e.printStackTrace();

        }

        logger.info("end executeAsync");

    }

}

这个方法做的事情很简单：sleep了一秒钟；

创建controller

创建一个controller为Hello，里面定义一个http接口，做的事情是调用Service层的服务，如下：

@RestController

public class Hello {

    private static final Logger logger = LoggerFactory.getLogger(Hello.class);

    @Autowired

    private AsyncService asyncService;

    @RequestMapping("/")

    public String submit(){

        logger.info("start submit");

        //调用service层的任务

        asyncService.executeAsync();

        logger.info("end submit");

        return "success";

    }

}

至此，我们已经做好了一个http请求的服务，里面做的事情其实是同步的，接下来我们就开始配置springboot的线程池服务，将service层做的事情都提交到线程池中去处理；

springboot的线程池配置

创建一个配置类ExecutorConfig，用来定义如何创建一个ThreadPoolTaskExecutor，要使用@Configuration和@EnableAsync这两个注解，表示这是个配置类，并且是线程池的配置类，如下所示：

@Configuration

@EnableAsync

public class ExecutorConfig {

    private static final Logger logger = LoggerFactory.getLogger(ExecutorConfig.class);

    @Bean

    public Executor asyncServiceExecutor() {

        logger.info("start asyncServiceExecutor");

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        //配置核心线程数

        executor.setCorePoolSize(5);

        //配置最大线程数

        executor.setMaxPoolSize(5);

        //配置队列大小

        executor.setQueueCapacity(99999);

        //配置线程池中的线程的名称前缀

        executor.setThreadNamePrefix("async-service-");

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务

        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        //执行初始化

        executor.initialize();

        return executor;

    }

}

注意，上面的方法名称为asyncServiceExecutor，稍后马上用到；

将Service层的服务异步化

打开AsyncServiceImpl.java，在executeAsync方法上增加注解@Async(“asyncServiceExecutor”)，asyncServiceExecutor是前面ExecutorConfig.java中的方法名，表明executeAsync方法进入的线程池是asyncServiceExecutor方法创建的，如下：

@Override

    @Async("asyncServiceExecutor")

    public void executeAsync() {

        logger.info("start executeAsync");

        try{

            Thread.sleep(1000);

        }catch(Exception e){

            e.printStackTrace();

        }

        logger.info("end executeAsync");

    }

验证效果

  1. 将这个springboot运行起来（pom.xml所在文件夹下执行mvn spring-boot:run）；
  2. 在浏览器输入：http://localhost:8080；
  3. 在浏览器用F5按钮快速多刷新几次；
  4. 在springboot的控制台看见日志如下：
2018-01-21 22:43:18.630  INFO 14824 --- [nio-8080-exec-8] c.b.t.controller.Hello                   : start submit

2018-01-21 22:43:18.630  INFO 14824 --- [nio-8080-exec-8] c.b.t.controller.Hello                   : end submit

2018-01-21 22:43:18.929  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:18.930  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

2018-01-21 22:43:19.005  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:19.006  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

2018-01-21 22:43:19.175  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:19.175  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

2018-01-21 22:43:19.326  INFO 14824 --- [async-service-4] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:19.495  INFO 14824 --- [async-service-5] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:19.930  INFO 14824 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:20.006  INFO 14824 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 22:43:20.191  INFO 14824 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

如上日志所示，我们可以看到controller的执行线程是”nio-8080-exec-8”，这是tomcat的执行线程，而service层的日志显示线程名为“async-service-1”，显然已经在我们配置的线程池中执行了，并且每次请求中，controller的起始和结束日志都是连续打印的，表明每次请求都快速响应了，而耗时的操作都留给线程池中的线程去异步执行；

扩展ThreadPoolTaskExecutor

虽然我们已经用上了线程池，但是还不清楚线程池当时的情况，有多少线程在执行，多少在队列中等待呢？这里我创建了一个ThreadPoolTaskExecutor的子类，在每次提交线程的时候都会将当前线程池的运行状况打印出来，代码如下：

public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);

    private void showThreadPoolInfo(String prefix){

        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if(null==threadPoolExecutor){

            return;

        }

        logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",

                this.getThreadNamePrefix(),

                prefix,

                threadPoolExecutor.getTaskCount(),

                threadPoolExecutor.getCompletedTaskCount(),

                threadPoolExecutor.getActiveCount(),

                threadPoolExecutor.getQueue().size());

    }

    @Override

    public void execute(Runnable task) {

        showThreadPoolInfo("1. do execute");

        super.execute(task);

    }

    @Override

    public void execute(Runnable task, long startTimeout) {

        showThreadPoolInfo("2. do execute");

        super.execute(task, startTimeout);

    }

    @Override

    public Future<?> submit(Runnable task) {

        showThreadPoolInfo("1. do submit");

        return super.submit(task);

    }

    @Override

    public <T> Future<T> submit(Callable<T> task) {

        showThreadPoolInfo("2. do submit");

        return super.submit(task);

    }

    @Override

    public ListenableFuture<?> submitListenable(Runnable task) {

        showThreadPoolInfo("1. do submitListenable");

        return super.submitListenable(task);

    }

    @Override

    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {

        showThreadPoolInfo("2. do submitListenable");

        return super.submitListenable(task);

    }

}

如上所示，showThreadPoolInfo方法中将任务总数、已完成数、活跃线程数，队列大小都打印出来了，然后Override了父类的execute、submit等方法，在里面调用showThreadPoolInfo方法，这样每次有任务被提交到线程池的时候，都会将当前线程池的基本情况打印到日志中；

修改ExecutorConfig.java的asyncServiceExecutor方法，将ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor()改为ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor()，如下所示：

@Bean

    public Executor asyncServiceExecutor() {

        logger.info("start asyncServiceExecutor");

        //使用VisiableThreadPoolTaskExecutor

        ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();

        //配置核心线程数

        executor.setCorePoolSize(5);

        //配置最大线程数

        executor.setMaxPoolSize(5);

        //配置队列大小

        executor.setQueueCapacity(99999);

        //配置线程池中的线程的名称前缀

        executor.setThreadNamePrefix("async-service-");

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务

        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        //执行初始化

        executor.initialize();

        return executor;

    }
  • 1

再次启动该工程，再浏览器反复刷新http://localhost:8080，看到的日志如下：

2018-01-21 23:04:56.113  INFO 15580 --- [nio-8080-exec-1] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [99], completedTaskCount [85], activeCount [5], queueSize [9]

2018-01-21 23:04:56.113  INFO 15580 --- [nio-8080-exec-1] c.b.t.controller.Hello                   : end submit

2018-01-21 23:04:56.225  INFO 15580 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 23:04:56.225  INFO 15580 --- [async-service-1] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.controller.Hello                   : start submit

2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [100], completedTaskCount [86], activeCount [5], queueSize [9]

2018-01-21 23:04:56.240  INFO 15580 --- [nio-8080-exec-2] c.b.t.controller.Hello                   : end submit

2018-01-21 23:04:56.298  INFO 15580 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 23:04:56.298  INFO 15580 --- [async-service-2] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

2018-01-21 23:04:56.372  INFO 15580 --- [nio-8080-exec-3] c.b.t.controller.Hello                   : start submit

2018-01-21 23:04:56.373  INFO 15580 --- [nio-8080-exec-3] c.b.t.e.VisiableThreadPoolTaskExecutor   : async-service-, 2. do submit,taskCount [101], completedTaskCount [87], activeCount [5], queueSize [9]

2018-01-21 23:04:56.373  INFO 15580 --- [nio-8080-exec-3] c.b.t.controller.Hello                   : end submit

2018-01-21 23:04:56.444  INFO 15580 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : end executeAsync

2018-01-21 23:04:56.445  INFO 15580 --- [async-service-3] c.b.t.service.impl.AsyncServiceImpl      : start executeAsync

注意这一行日志：2. do submit,taskCount [101], completedTaskCount [87], activeCount [5], queueSize [9]

这说明提交任务到线程池的时候，调用的是submit(Callable task)这个方法，当前已经提交了101个任务，完成了87个，当前有5个线程在处理任务，还剩9个任务在队列中等待，线程池的基本情况一路了然；

至此，springboot线程池服务的实战就完成了，希望能帮您在工程中快速实现异步服务；

spring-boot 方法异步调用，自定义线程池配置使用

1、在主类中添加@EnableAsync注解：

@SpringBootApplication

@EnableScheduling

@EnableAsync

public class MySpringBootApplication {

	private static Logger logger = LoggerFactory.getLogger(MySpringBootApplication.class);

	public static void main(String[] args) {

		SpringApplication.run(MySpringBootApplication.class, args);

		logger.info("My Spring Boot Application Started");

	}

2、创建一个AsyncTask类，在里面添加两个用@Async注解的task：

@Component

public class AsyncTask {

	protected final Logger logger = LoggerFactory.getLogger(this.getClass());

	@Async

	public Future<String> doTask1() throws InterruptedException{

		logger.info("Task1 started.");

		long start = System.currentTimeMillis();

        Thread.sleep(5000);

        long end = System.currentTimeMillis();

        logger.info("Task1 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task1 accomplished!");

	}

	@Async

	public Future<String> doTask2() throws InterruptedException{

		logger.info("Task2 started.");

		long start = System.currentTimeMillis();

        Thread.sleep(3000);

        long end = System.currentTimeMillis();

        logger.info("Task2 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task2 accomplished!");

	}

}

3、万事俱备，开始测试：



public class TaskTests extends BasicUtClass{

	@Autowired

	private AsyncTask asyncTask;

	@Test

	public void AsyncTaskTest() throws InterruptedException, ExecutionException {

		Future<String> task1 = asyncTask.doTask1();

		Future<String> task2 = asyncTask.doTask2();

		while(true) {

			if(task1.isDone() && task2.isDone()) {

				logger.info("Task1 result: {}", task1.get());

				logger.info("Task2 result: {}", task2.get());

				break;

			}

			Thread.sleep(1000);

		}

		logger.info("All tasks finished.");

	}

}

测试结果：

2016-12-13 11:12:24,850:INFO main (AsyncExecutionAspectSupport.java:245) - No TaskExecutor bean found for async processing

2016-12-13 11:12:24,864:INFO SimpleAsyncTaskExecutor-1 (AsyncTask.java:22) - Task1 started.

2016-12-13 11:12:24,865:INFO SimpleAsyncTaskExecutor-2 (AsyncTask.java:34) - Task2 started.

2016-12-13 11:12:27,869:INFO SimpleAsyncTaskExecutor-2 (AsyncTask.java:39) - Task2 finished, time elapsed: 3001 ms.

2016-12-13 11:12:29,866:INFO SimpleAsyncTaskExecutor-1 (AsyncTask.java:27) - Task1 finished, time elapsed: 5001 ms.

2016-12-13 11:12:30,853:INFO main (TaskTests.java:23) - Task1 result: Task1 accomplished!

2016-12-13 11:12:30,853:INFO main (TaskTests.java:24) - Task2 result: Task2 accomplished!

2016-12-13 11:12:30,854:INFO main (TaskTests.java:30) - All tasks finished.

可以看到，没有自定义的Executor，所以使用缺省的TaskExecutor 。

前面是最简单的使用方法。如果想使用自定义的Executor，可以按照如下几步来：

1、新建一个Executor配置类，顺便把@EnableAsync注解搬到这里来：

@Configuration

@EnableAsync

public class ExecutorConfig {

	/** Set the ThreadPoolExecutor's core pool size. */

	private int corePoolSize = 10;

	/** Set the ThreadPoolExecutor's maximum pool size. */

	private int maxPoolSize = 200;

	/** Set the capacity for the ThreadPoolExecutor's BlockingQueue. */

	private int queueCapacity = 10;

	@Bean

	public Executor mySimpleAsync() {

		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

		executor.setCorePoolSize(corePoolSize);

		executor.setMaxPoolSize(maxPoolSize);

		executor.setQueueCapacity(queueCapacity);

		executor.setThreadNamePrefix("MySimpleExecutor-");

		executor.initialize();

		return executor;

	}

	@Bean

	public Executor myAsync() {

		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

		executor.setCorePoolSize(corePoolSize);

		executor.setMaxPoolSize(maxPoolSize);

		executor.setQueueCapacity(queueCapacity);

		executor.setThreadNamePrefix("MyExecutor-");

		// rejection-policy：当pool已经达到max size的时候，如何处理新任务

		// CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

		executor.initialize();

		return executor;

	}

}

这里定义了两个不同的Executor，第二个重新设置了pool已经达到max size时候的处理方法；同时指定了线程名字的前缀。

2、自定义Executor的使用：

@Component

public class AsyncTask {

	protected final Logger logger = LoggerFactory.getLogger(this.getClass());

	@Async("mySimpleAsync")

	public Future<String> doTask1() throws InterruptedException{

		logger.info("Task1 started.");

		long start = System.currentTimeMillis();

        Thread.sleep(5000);

        long end = System.currentTimeMillis();

        logger.info("Task1 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task1 accomplished!");

	}

	@Async("myAsync")

	public Future<String> doTask2() throws InterruptedException{

		logger.info("Task2 started.");

		long start = System.currentTimeMillis();

        Thread.sleep(3000);

        long end = System.currentTimeMillis();

        logger.info("Task2 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task2 accomplished!");

	}

}

就是把上面自定义Executor的类名，放进@Async注解中。

3、（测试用例不变）测试结果：

2016-12-13 10:57:11,998:INFO MySimpleExecutor-1 (AsyncTask.java:22) - Task1 started.

2016-12-13 10:57:12,001:INFO MyExecutor-1 (AsyncTask.java:34) - Task2 started.

2016-12-13 10:57:15,007:INFO MyExecutor-1 (AsyncTask.java:39) - Task2 finished, time elapsed: 3000 ms.

2016-12-13 10:57:16,999:INFO MySimpleExecutor-1 (AsyncTask.java:27) - Task1 finished, time elapsed: 5001 ms.

2016-12-13 10:57:17,994:INFO main (TaskTests.java:23) - Task1 result: Task1 accomplished!

2016-12-13 10:57:17,994:INFO main (TaskTests.java:24) - Task2 result: Task2 accomplished!

2016-12-13 10:57:17,994:INFO main (TaskTests.java:30) - All tasks finished.

2016-12-13 10:57:18,064 Thread-3 WARN Unable to register Log4j shutdown hook because JVM is shutting down. Using SimpleLogger

可见，线程名字的前缀变了，两个task使用了不同的线程池了。

参考博客：http://blog.csdn.net/clementad/article/details/53607311

springboot线程池的使用和扩展(转)的更多相关文章

  1. springboot线程池的使用和扩展

    我们常用ThreadPoolExecutor提供的线程池服务,springboot框架提供了@Async注解,帮助我们更方便的将业务逻辑提交到线程池中异步执行,今天我们就来实战体验这个线程池服务: 本 ...

  2. springboot线程池@Async的使用和扩展

    我们常用ThreadPoolExecutor提供的线程池服务,springboot框架提供了@Async注解,帮助我们更方便的将业务逻辑提交到线程池中异步执行,今天我们就来实战体验这个线程池服务: 本 ...

  3. springboot 线程池

    我们常用ThreadPoolExecutor提供的线程池服务,springboot框架提供了@Async注解,帮助我们更方便的将业务逻辑提交到线程池中异步执行,今天我们就来实战体验这个线程池服务: 本 ...

  4. Spring Boot 线程池的使用和扩展 - 转载

    转载:http://blog.csdn.net/boling_cavalry/article/details/79120268 1.实战环境 windowns10: jdk1.8: springboo ...

  5. [开源项目]可观测、易使用的SpringBoot线程池

    在开发spring boot应用服务的时候,难免会使用到异步任务及线程池.spring boot的线程池是可以自定义的,所以我们经常会在项目里面看到类似于下面这样的代码 @Bean public Ex ...

  6. springboot线程池任务调度类 -- ThreadPoolTaskScheduler介绍

    springboot中有一个bean,ThreadPoolTaskScheduler,可以很方便的对重复执行的任务进行调度管理:相比于通过java自带的周期性任务线程池ScheduleThreadPo ...

  7. Springboot 线程池配置

    最近的项目里要手动维护线程池,然后看到一起开发的小伙伴直接用Java了,我坚信Springboot不可能没这功能,于是查了些资料,果然有,这里给一下. 首先我们都知道@Async标签能让方法异步执行, ...

  8. SpringBoot 线程池配置 实现AsyncConfigurer接口方法

      目的是:  通过实现AsyncConfigurer自定义线程池,包含异常处理  实现AsyncConfigurer接口对异常线程池更加细粒度的控制 *a) 创建线程自己的线程池  b) 对void ...

  9. SpringBoot线程池的创建、@Async配置步骤及注意事项

    最近在做订单模块,用户购买服务类产品之后,需要进行预约,预约成功之后分别给商家和用户发送提醒短信.考虑发短信耗时的情况所以我想用异步的方法去执行,于是就在网上看见了Spring的@Async了. 但是 ...

随机推荐

  1. android调节声音大小

    android调节声音大小 1.背景音乐的一些知识 网上好多关于背景音乐添加用到的类: MediaPlayer,SoundPool,AudioManager的资料,可是有时候解决不了我们在开发中遇到的 ...

  2. tensorflow variable的保存和修改（加载一部分variable到新的model中）

    link: https://www.tensorflow.org/guide/saved_model 中文博客:https://blog.csdn.net/Searching_Bird/article ...

  3. jQuery预览图

  4. centos7配置svn钩子hooks脚本自动同步代码到项目目录

    由于项目需要,svn提交后的代码希望再测试服务器上测试,每次提交后还要手动去svn update一次 十分麻烦,配置好svn钩子以后就省去了这些麻烦. 进入svn版本库目录找到hooks目录找到文件p ...

  5. echarts地图定时切换散点及多图表级联联动

    本文目录 1. 摘要 2.引入ECharts以及地图相关json 3. 界面布局 4. js实现图形布局 5.定时循环jquery实现 6. 总结 1.  摘要 最近做项目遇到个统计相关需求,一个页面 ...

  6. 【LeetCode】65. Valid Number

    Difficulty: Hard  More:[目录]LeetCode Java实现 Description Validate if a given string can be interpreted ...

  7. 【转】tair与redis比较总结

    1. Tair总述 1.1 系统架构 一个Tair集群主要包括3个必选模块:configserver.dataserver和client,一个可选模块:invalidserver.通常情况下,一个集群 ...

  8. [转]Splay算法

    首先声明,本教程的对象是完全没有接触过splay的OIer,大牛请右上角. 先看一道题目: skydec有n个数,每次他都会把一些数放进一些盒子里,由于skydec太傻×,所以他不能判断数的大小,现在 ...

  9. Linux-C基础编程

    GCC工作流程 工作流程 1.预处理 -E xxx.c —> xxx.i 宏替换:头文件展开:注释去掉: gcc -E hello.c -o hello.i 2.编译 -S xxx.i —> ...

  10. 基于.htaccess的Web Shell工具htshells

    基于.htaccess的Web Shell工具htshells   .htaccess文件是Apache服务器的配置文件.它负责相关目录下的网页配置.一旦用户获得修改该文件的权限,就可以基于该文件构建 ...