单核cpu多线程有必要吗？

问题分析

现代计算机一般都是多核cpu，多线程的可以大大提高效率，但是可能会有疑问，那单核CPU使用多线程是不是没有必要了，假定一种情况，

web应用服务器，单核CPU、单线程

，用户发过来请求，单个线程处理，CPU等待这个线程的处理结果返回，查询数据库，CPU等待查询结果...，只有一个线程的话，每次线程在处理的过程中CPU都有大量的空闲等待时间，那这样来说并行和串行似乎并没有体现并行的优势，因为任务的总量在那里，实际情况肯定不是这样的，即便是单核CPU，一个进程中往往也是有多个线程存在的，每个线程各司其职，CPU来调度各线程。

这里需要区分CPU处理指令和IO读取的不同，CPU的执行速度要远大于IO的过程，因此在大多数情况下多一些复杂的CPU计算都比增加一次IO要快，这一块深入理解要学习计算机原理相关的知识。

现实生活中也是有很多类似的例子，比如厨师做一道菜，买菜和买配料需要去不同的两个商店，如果这个过程只依靠他一个人来做，那耗费的总时间就是买菜再去买调料的总时间，如果有一个帮厨，那么就可以兵分两路，再来汇总结果，时间基本可以减半，厨师和帮厨就是不同的线程。

编程是高度抽象生活的一门艺术。

场景模拟

模拟单线程和多线程的效率差距，这里使用连接数据库，和读取磁盘文件来模拟IO操作，期望结果：

单线程总耗时：数据库连接耗时 + 磁盘文件读取耗时
多线程总耗时：约等于耗时最长的那个时间

读取文件：https://gitee.com/chsoul/javase/blob/master/medias/testIO.txt

MySQL8.0 连接驱动：https://gitee.com/chsoul/javase/blob/master/medias/mysql-connector-java-8.0.18.jar

代码如下：

package com.thread.demo;

import java.io.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author Vicente
 * @version 1.0
 * @date 2020/4/6 21:53
 */
public class Test {
    /**
     * 数据库连接
     */
    public static void getMysqlData(){
        long t1 = System.currentTimeMillis();
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true";
        String userName = "root";
        String password = "root";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection = DriverManager.getConnection(url, userName, password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        long t2 = System.currentTimeMillis();
        System.out.println("数据库连接完成！耗时："+(t2 - t1));
    }

    /**
     * 磁盘读取
     */
    public static void getDiskData(){
        long t1 = System.currentTimeMillis();
        File file = new File("src/com/thread/demo/test.txt");
        StringBuilder stb = new StringBuilder();
        InputStream is = null;
        try {
            is = new FileInputStream(file);
            int read = 0;
            while ((read = is.read()) != -1) {
                char c = (char) read;
                stb.append(c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long t2 = System.currentTimeMillis();
        System.out.println("磁盘文件读取结束！耗时："+(t2 - t1));
    }

    public static void main(String[] args){
        System.out.println("-----------------单线程执行任务开始-----------------");
        long start = System.currentTimeMillis();
        getMysqlData();
        getDiskData();
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end - start));
        System.out.println("-----------------单线程执行任务结束-----------------");
        System.out.println("\r\n");
        try {
            System.out.println("-----------------多线程执行任务开始-----------------");
            long start1 = System.currentTimeMillis();
            FutureTask dbWork = new FutureTask(new DbDataWork());
            FutureTask diskWork = new FutureTask(new DiskDataWork());
            new Thread(dbWork).start();
            new Thread(diskWork).start();
            while (diskWork.get().equals("DISK_OK") && dbWork.get().equals("DB_OK")){
                long end1 = System.currentTimeMillis();
                System.out.println("总耗时："+(end1 - start1));
                System.out.println("-----------------多线程执行任务结束-----------------");
                break;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 数据库连接任务类
 */
class DbDataWork implements Callable<String> {
    @Override
    public String call() throws Exception {
        long t1 = System.currentTimeMillis();
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true";
        String userName = "root";
        String password = "root";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection = DriverManager.getConnection(url, userName, password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        long t2 = System.currentTimeMillis();
        System.out.println("数据库连接线程任务结束！耗时："+(t2 - t1));
        return "DB_OK";
    }
}

/**
 * 磁盘读取任务类
 */
class DiskDataWork implements Callable<String>{
    @Override
    public String call() throws Exception {
        long t1 = System.currentTimeMillis();
        File file = new File("src/com/thread/demo/test.txt");
        StringBuilder stb = new StringBuilder();
        InputStream is = null;
        try {
            is = new FileInputStream(file);
            int read = 0;
            while ((read = is.read()) != -1) {
                char c = (char) read;
                stb.append(c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long t2 = System.currentTimeMillis();
        System.out.println("磁盘读取线程任务结束！耗时："+(t2 - t1));
        return "DISK_OK";
    }
}

执行结果：

-----------------单线程执行任务开始-----------------
数据库连接完成！耗时：694
磁盘文件读取结束！耗时：558
总耗时：1253
-----------------单线程执行任务结束-----------------

-----------------多线程执行任务开始-----------------
数据库连接线程任务结束！耗时：743
磁盘读取任务结束！耗时：752
总耗时：755
-----------------多线程执行任务结束-----------------

总结

结果符合预期，这也说明在有频繁的IO操作时使用多线程会大大提高程序的执行效率。
有兴趣的同学可以试一下在执行i++的情况下，多线程就一定快吗？单线程和多线程的临界值是什么？

附：

• 为什么Redis单线程却很快，在没有磁盘IO的情况下单核CPU绑定一块内存效率最高，Redis把读写操作都放在了CPU和内存的部分，又减少了多线程上下文 切换的过程，因此Redis即便是单线程也很快，在现代多核CPU的服务器中，往往会通过根据绑定Redis进程和CPU提高性能。
• 《性能调优攻略》在多核CPU调优章节提到，我们不能任由操作系统负载均衡，因为我们自己更了解自己的程序，所以，我们可以手动地为其分配CPU核，而不会过多地占用CPU0，或是让我们关键进程和一堆别的进程挤在一起。在文章中提到了Linux下的一个工具，taskset，可以设定单个进程运行的CPU。 详细可参考：https://www.cnblogs.com/blogtech/p/11742057.html