项目优化（数据库优化、多线程、CountDownLatch）

最近有一个新需求，因为公司的需要，需要开发一个内部员工使用的销售操作台。具体使用场景如下：

每个员工开始时都需要登录，登录之后展示公司数据库中的所有企业信息（需要展示的内容如下：企业名称、企业统一社会信用代码、企业产品、企业级别（标准、会员之类的）、企业被访问次数、企业余额）。然后用户可以操作每一条企业信息，让其置顶或取消置顶。

功能虽然是新功能，但是数据库表之前早已经存在了，表设计如下：

首先呢，有一个company表，存放的是企业的基本信息，如名称、统一信用代码、级别等。

接下来呢，有一个company_access表，记录的是企业被访问的记录（时间等）。

第三呢，有一个company_money表，记录的是企业的充值消费记录。

功能已经明确了，数据库也已经有了，接下来就是开发了。

一开始当然是写接口喽，登录什么的都就不说了，直接说核心的接口。登录之后，首先从company表查询所有的企业，用一个List集合接收。然后遍历List集合，去查询每个企业的访次及余额，最后返回到前端展示。代码唰唰唰写完了，测试也没有问题，就是速度慢了一点儿（大概5S的样子，已经不能用慢来形容了，哈哈哈）。那么就要开始追踪时间是耗费在哪里了？

首先，在接口入口处获取时间戳，出口处获取时间戳，果不其然，时间都耗在接口上了。那么就需要进一步分析了。

第一，先去看sql执行的时间。查询company表还好，差不多10毫秒吧，挺正常的。

再看第二个查询企业访次的sql.哇，问题来了呀。一个企业的访次查询竟然耗费了40毫秒，余额查询耗费了1毫秒。但是数据库中一共差不多100个企业吧，加起来就是差不多4秒钟了。再加上其他的程序处理以及网络传输，一次请求差不多就是5秒钟。

问题找到了，那怎么优化呢？

首先查看数据库数据。企业访次记录表company_access一共有3W多条数据，查看表结构。恩，没有索引~~~好办，根据查询字段加个索引呗。企业信息表company和企业充值消费记录表company_money数据不多，可以暂时不做优化。当然也就顺便加了个索引。

加完索引后再次调用接口。恩，效果很明显，请求发出到接收到返回，大概是2.5秒的样子，快了一倍。但是仍旧很慢，那怎么办呢？

项目用的是SSM，查看配置文件，配置了数据库连接池，那么在获取数据库连接对象的时耗可以不考虑。那么怎么办呢？多线程。

第一次开发的时候，项目中使用的是单线程，很多个任务放在一个单线程中执行，耗时肯定是不可避免的喽。用的是SSM框架，那就用spring中的线程池了呗。配置如下：

<!-- 线程池 -->
<bean id="taskExecutor"
	class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
	<!-- 线程池维护线程的最少数量 -->
	<property name="corePoolSize" value="5" />
	<!-- 允许的空闲时间 -->
	<property name="keepAliveSeconds" value="200" />
	<!-- 线程池维护线程的最大数量 -->
	<property name="maxPoolSize" value="10" />
	<!-- 缓存队列 -->
	<property name="queueCapacity" value="20" />
	<!-- 对拒绝task的处理策略 -->
	<property name="rejectedExecutionHandler">
		<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
	</property>
</bean>

重写Runnable接口：

class MyRunnable implements Runnable{

        private TComInfo comInfo;//项目中的企业实体类
        
        private CountDownLatch latch = null;
        
        public MyRunnable(CountDownLatch latch,TComInfo comInfo) {
            // TODO Auto-generated constructor stub
            this.latch = latch;
            this.comInfo = comInfo;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            /**    查询企业的访次    */
            /**    查询企业的消费充值记录    */
            latch.countDown();
        }
        
    }

代码中调用线程池：

//comList为查询到的企业集合
final CountDownLatch countDown = new CountDownLatch(comList.size());
for(int i=0;i<comList.size();i++){
    TComInfo comInfo = comList.get(i);
    taskExecutor.execute(new MyRunnable(countDown, comInfo));//taskExecutor是注解配置在当前的调用类中线程池对象
}
try {
    countDown.await();
} catch (InterruptedException e) {
    e.printStackTrace();
}

修改完毕，开始测试。请求接口到接收到接口的返回，一共耗时不到1秒钟，而且此时的企业数量已经不是100左右了，已经增长到500多了。

多线程中使用了CountDownLatch这个类，这个类是java.util.concurrent包中的，是用来提供线程间通信的。这个类有什么用呢？先来看看不使用这个类的话是什么情况。

package executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorTest {

    public void test() {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        int i = 10;
        for (int j = 0; j < i; j++) {
            threadPool.execute(new MyRunnable(j));
        }
        System.out.println("执行完毕");
    }

    class MyRunnable implements Runnable {

        private int i;

        public MyRunnable(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            System.out.println("这是第" + i + "个线程");
        }

    }

}

测试运行类：

package executor;

public class Test {

    public static void main(String[] args) {
        ExecutorTest test = new ExecutorTest();
        test.test();
    }
}

运行结果如下：

可以看到执行结果，线程池中的任务还没有全部执行完毕，主线程就已经执行完了（线程池是在主线程中开辟的）。那要怎样才能让主线程在线程池中的任务全部执行完毕之后再继续执行呢？

看如下修改：

package executor;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorTest {

    public void test() {
        CountDownLatch countDown = new CountDownLatch(10);
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        int i = 10;
        for (int j = 0; j < i; j++) {
            threadPool.execute(new MyRunnable(j, countDown));
        }
        try {
            countDown.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行完毕");
    }

    class MyRunnable implements Runnable {

        private int i;
        private CountDownLatch countDown;

        public MyRunnable(int i, CountDownLatch countDown) {
            this.i = i;
            this.countDown = countDown;
        }

        @Override
        public void run() {
            System.out.println("这是第" + i + "个线程");
            countDown.countDown();
        }
    }
}

再执行测试运行类：

使用了CountDownLatch 这个类。可以看到在主线程中定义了一个CountDownLatch对象，这个对象中维护了一个计数器，计数器的个数是通过构造函数传递进去的。这个对象是怎么使用的呢？主线程中创建线程池之后，先调用CountDownLatch对象的await()方法，调用了await()方法之后，当前线程就会阻塞，只有在CountDownLatch对象中的计数器个数为0的时候才会唤醒当前线程。CountDownLatch对象定义时计数器的个数已经制定了，而计数器的数量消减是在线程池中的子线程中完成的。线程池中的线程每执行完一个任务，CountDownLatch对象就调用countDown()方法，那么计数器就会减一。最后，所有任务执行完之后，计数器的数量为0，主线程被唤醒，继续执行接下来的步骤。

总结：使用CountDownLatch对象的时候，可以搭配线程池使用（当然也可以是只有一个主线程和一个单线程，那样CountDownLatch对象中维护的计数器就应该定义为1了）。步骤如下：

1. 计数器的个数应该定义为任务的总数，而不是子线程的数量（因为线程池中维护的线程数量是有限的，是有限个数的线程去执行指定个数的任务）。

2. 主线程创建线程池之后调用CountDownLatch对象的await方法，让主线程阻塞。

3. 在任务中调用CountDownLatch对象的countDown方法，让CountDownLatch对象的计数器消减。