线程数多和少会对程序有什么影响？

单线程执行执行IO操作的时间对比

3条多线程执行IO操作的时间对比

30条多线程执行IO操作的时间对比

300条多线程执行IO操作的时间对比

从执行结果来看，线程数的增加使得效率升高再降低。

那么，影响的因素有哪些？

1可以知道，最最关键的就是IO操作，在IO操作上加了同步锁，所以IO操作串行化了，影响可以忽略不计。如果是有多张表的情况下，多线程仍然会占据优势。

2IO串行化，那么影响因素只有创建对象和set值的代码了，可以看出多线程下确实会减少时间，这个时间就是创建对象所消耗的时间了，然而在线程数更多的情况下，时间却有所增加，这个是多线程切换造成的时间损耗（当然有可能包括其他）。

3如果创建对象所消耗的时间更长，那么结果的差距会更大

加入线程sleep1毫秒

单线程下

30条多线程下

可以看到，多线程更加占据优势

当然，以上结果依托于重复执行，例如A方法执行100次。

如果是单次的执行，那么结果可能就又不一样了。多线程的其它线程可能派不上用场，同时又消耗了创建线程的时间，这里不再进行测试。

附上代码

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

@RunWith(SpringRunner.class)
@SpringBootTest
public class ThreadCoreApplicationTests {

    @Autowired
    private CoreRepository coreRepository;

    @Test
    public void contextLoads() {
    }


    /**
     * Test
     */
    @Test
    public void testThread() {

        //单/多线程线程池
        ExecutorService executorService = Executors.newFixedThreadPool(30);

        Task task = new Task();
        Long beforeTime = System.currentTimeMillis();
        for(int i = 0; i< 5000; i++){
            executorService.execute(task);
        }
        //不再接受新任务
        executorService.shutdown();
        //是否全部执行完成
        while(true) {
            if(executorService.isTerminated()) {
                Long afterTime = System.currentTimeMillis();
                System.out.println((afterTime-beforeTime)+"---------------------------------------------------------");
                break;
            }
        }


    }

    class Task implements Runnable {
        @Override
        public void run() {
            //System.out.print("Hello");
            Core core = new Core();
            core.setCurrentThread(Thread.currentThread().getName());
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this) {
                coreRepository.save(core);
            }
        }
    }

}

import lombok.Data;
import org.springframework.boot.autoconfigure.domain.EntityScan;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
@Data
public class Core {

    @Id
    @GeneratedValue
    private Integer coreId;
    /**
     * 当前执行的线程
     */
    private String currentThread;
    /**
     * 写入字符串
     */
    private String threadString;
}

这里测试的结果也与IO密集型，计算密集型相关。附上写得不错的文章。

https://www.cnblogs.com/-new/p/7234332.html