Java多线程查询多表操作

Java实现多线程的方式有几种：

    1.继承Thread类，重写run()方法，通过start()方法运行run()方法；

    2.实现Runnable接口，同样是重写run()方法；

    3.实现Callable接口通过FutureTask包装器来创建Thread线程；

    4.线程池。

我这里是实现Runnable接口来创建多线程：

import com.example.demo.dao.TeacherDao;
import com.example.demo.model.entity.TeacherEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;

public class ThreadForTeacher implements Runnable {

    private final Logger logger = LoggerFactory.getLogger(ThreadForTeacher.class);
    private CountDownLatch countDownLatch;
    private TeacherDao teacherDao;
    public ConcurrentHashMap<String, List<TeacherEntity>> classMap = new ConcurrentHashMap<>();

    @Override
    public void run() {
        logger.info("-------------查询教师信息-------------");
        try {
            List<TeacherEntity> teacherList = teacherDao.queryTeacherList();
            classMap.put("teacherList", teacherList);
        } finally {
            // 防止线程执行时出现异常
            countDownLatch.countDown();
        }
    }

    public ThreadForTeacher(CountDownLatch countDownLatch, TeacherDao teacherDao) {
        this.countDownLatch = countDownLatch;
        this.teacherDao = teacherDao;
    }
}

看代码，我这里用到了CountDownLatch，下面我们再来说说CountDownLatch的作用：

    1.简单的说，CountDownLatch就是一个计数器，常用的两个方法分别是：

        countDown() 计数减一

        await() 等待所有线程计数到0时，并行执行，也就是等待所有线程创建完成后同时执行

使用场景：当我们需要拿到所有线程返回的结果并对数据进行组装（需要返回值，我们可以实现Callable接口，当线程执行完后可以获取一个Future对象，通过get()方法拿到返回结果，我这里偷个懒直接用Runnable实现）；

上面只贴出了创建Teacher的线程，Student和Classes同上，只是Entity和Dao的不同；

那么在service层我们是怎么去调用的呢，而且上面teacherDao我并没有加@Atuowried注解，说明teacherDao是Null，再看看上面我们的构造函数，我们在创建ThreadForTeacher对象把teacherDao传过来，这样teacherDao就不再是Null；

下面我们一起来看看代码：

import com.alibaba.fastjson.JSON;
import com.example.demo.dao.ClassDao;
import com.example.demo.dao.StudentDao;
import com.example.demo.dao.TeacherDao;
import com.example.demo.model.entity.ClassEntity;
import com.example.demo.model.entity.StudentEntity;
import com.example.demo.model.entity.TeacherEntity;
import com.example.demo.service.ThreadService;
import com.example.demo.thread.ThreadForClass;
import com.example.demo.thread.ThreadForStudent;
import com.example.demo.thread.ThreadForTeacher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Service
public class ThreadServiceImpl implements ThreadService {

    private final Logger logger = LoggerFactory.getLogger(ThreadServiceImpl.class);
    @Autowired
    private ClassDao classDao;
    @Autowired
    private TeacherDao teacherDao;
    @Autowired
    private StudentDao studentDao;


    @Override
    public void queryAll() {
        // 这里我创建了三个Thread，所以是new CountDownLatch(3)
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ThreadForClass threadForClass = new ThreadForClass(countDownLatch, classDao);
        ThreadForTeacher threadForTeacher = new ThreadForTeacher(countDownLatch, teacherDao);
        ThreadForStudent threadForStudent = new ThreadForStudent(countDownLatch, studentDao);
        // 创建线程池，保护线程运行
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 6, 2, TimeUnit.SECONDS, new LinkedBlockingDeque<>(), new ThreadPoolExecutor.DiscardOldestPolicy());
        threadPoolExecutor.execute(threadForClass);
        threadPoolExecutor.execute(threadForTeacher);
        threadPoolExecutor.execute(threadForStudent);
        try {
            // 等待所有线程执行结束
            countDownLatch.await();
        } catch (InterruptedException e) {
            logger.error("countDownLatch.await执行异常", e);
        } finally {
            threadPoolExecutor.shutdown();
        }
        List<ClassEntity> classList = threadForClass.classMap.get("classList");
        List<TeacherEntity> teacherList = threadForTeacher.classMap.get("teacherList");
        List<StudentEntity> studentList = threadForStudent.classMap.get("studentList");
        System.out.println("班级：" + JSON.toJSONString(classList));
        System.out.println("教师：" + JSON.toJSONString(teacherList));
        System.out.println("学生：" + JSON.toJSONString(studentList));
    }
}

Controller、Dao还有实体类的代码我就不贴出来，非常简单，相信每个人都会，我们运行一下看看是否能打印出我们想要的结果呢？一起来见证！

完全没毛病！

当我们需要去调用多个服务或者查询多表或者大量数据，我们就可以通过多线程编程去实现，提升代码执行效率！