码迷，mamicode.com
首页 > 编程语言 > 详细

多线程为什么跑的比单线程还要慢的情况分析及验证

时间：2015-03-11 23:29:07      阅读：4734      评论：0      收藏：0      [点我收藏+]

标签：多线程   性能   效率   编程   java   


2014-05-04 07:56:50cnblogs.com-Ethan Cai-点击数: 306

“多个人干活比一个人干活要快，多线程并行执行也比单线程要快”这是我学习编程长期以来的想法。然而在实际的开发过程中，并不是所有情况下都是这样。先看看下面的程序（点击下载）：

技术分享

ThreadTester是所有Tester的基类。所有的Tester都干的是同样一件事情，把counter增加到100000000，每次只能加1。

   1:publicabstractclass ThreadTester
   2:     {
   3:publicconstlong MAX_COUNTER_NUMBER = 100000000;
   4:  
   5:privatelong _counter = 0;
   6:  
   7://获得计数
   8:publicvirtuallong GetCounter()
   9:         {
  10:returnthis._counter;
  11:         }
  12:  
  13://增加计数器
  14:protectedvirtualvoid IncreaseCounter()
  15:         {
  16:this._counter += 1;
  17:         }
  18:  
  19://启动测试
  20:publicabstractvoid Start();
  21:  
  22://获得Counter从开始增加到现在的数字所耗的时间
  23:publicabstractlong GetElapsedMillisecondsOfIncreaseCounter();
  24:  
  25://测试是否正在运行
  26:publicabstractbool IsTesterRunning();
  27:     }

SingleThreadTester是单线程计数。

   1:class SingleThreadTester : ThreadTester
   2:     {
   3:private Stopwatch _aStopWatch = new Stopwatch();
   4:  
   5:publicoverridevoid Start()
   6:         {
   7:             _aStopWatch.Start();
   8:  
   9:             Thread aThread = new Thread(() => WorkInThread());
  10:             aThread.Start();
  11:         }
  12:  
  13:publicoverridelong GetElapsedMillisecondsOfIncreaseCounter()
  14:         {
  15:returnthis._aStopWatch.ElapsedMilliseconds;
  16:         }
  17:  
  18:publicoverridebool IsTesterRunning()
  19:         {
  20:return _aStopWatch.IsRunning;
  21:         }
  22:  
  23:privatevoid WorkInThread()
  24:         {
  25:while (true)
  26:             {
  27:if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
  28:                 {
  29:                     _aStopWatch.Stop();
  30:break;
  31:                 }
  32:  
  33:this.IncreaseCounter();
  34:             }
  35:         }
  36:     }

TwoThreadSwitchTester是两个线程交替计数。

   1:class TwoThreadSwitchTester : ThreadTester
   2:     {
   3:private Stopwatch _aStopWatch = new Stopwatch();
   4:private AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
   5:  
   6:publicoverridevoid Start()
   7:         {
   8:             _aStopWatch.Start();
   9:  
  10:             Thread aThread1 = new Thread(() => Work1InThread());
  11:             aThread1.Start();
  12:  
  13:             Thread aThread2 = new Thread(() => Work2InThread());
  14:             aThread2.Start();
  15:         }
  16:  
  17:publicoverridelong GetElapsedMillisecondsOfIncreaseCounter()
  18:         {
  19:returnthis._aStopWatch.ElapsedMilliseconds;
  20:         }
  21:  
  22:publicoverridebool IsTesterRunning()
  23:         {
  24:return _aStopWatch.IsRunning;
  25:         }
  26:  
  27:privatevoid Work1InThread()
  28:         {
  29:while (true)
  30:             {
  31:                 _autoResetEvent.WaitOne();
  32:
  33:this.IncreaseCounter();
  34:  
  35:if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
  36:                 {
  37:                     _aStopWatch.Stop();
  38:break;
  39:                 }
  40:  
  41:                 _autoResetEvent.Set();
  42:             }
  43:         }
  44:  
  45:privatevoid Work2InThread()
  46:         {
  47:while (true)
  48:             {
  49:                 _autoResetEvent.Set();
  50:                 _autoResetEvent.WaitOne();
  51:this.IncreaseCounter();
  52:  
  53:if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
  54:                 {
  55:                     _aStopWatch.Stop();
  56:break;
  57:                 }
  58:             }
  59:         }
  60:     }

MultiThreadTester可以指定线程数，多个线程争抢计数。

   1:class MultiThreadTester : ThreadTester
   2:     {
   3:private Stopwatch _aStopWatch = new Stopwatch();
   4:privatereadonlyint _threadCount = 0;
   5:privatereadonlyobject _counterLock = newobject();
   6:
   7:public MultiThreadTester(int threadCount)
   8:         {
   9:this._threadCount = threadCount;
  10:         }
  11:  
  12:publicoverridevoid Start()
  13:         {
  14:             _aStopWatch.Start();
  15:  
  16:for (int i = 0; i < _threadCount; i++)
  17:             {
  18:                 Thread aThread = new Thread(() => WorkInThread());
  19:                 aThread.Start();
  20:             }
  21:         }
  22:  
  23:publicoverridelong GetElapsedMillisecondsOfIncreaseCounter()
  24:         {
  25:returnthis._aStopWatch.ElapsedMilliseconds;
  26:         }
  27:  
  28:publicoverridebool IsTesterRunning()
  29:         {
  30:return _aStopWatch.IsRunning;
  31:         }
  32:  
  33:privatevoid WorkInThread()
  34:         {
  35:while (true)
  36:             {
  37:lock (_counterLock)
  38:                 {
  39:if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
  40:                     {
  41:                         _aStopWatch.Stop();
  42:break;
  43:                     }
  44:  
  45:this.IncreaseCounter();
  46:                 }
  47:             }
  48:         }
  49:     }

Program的Main函数中，根据用户的选择来决定执行哪个测试类。

   1:class Program
   2:     {
   3:staticvoid Main(string[] args)
   4:         {
   5:  
   6:string inputText = GetUserChoice();
   7:  
   8:while (!"4".Equals(inputText))
   9:             {
  10:                 ThreadTester tester = GreateThreadTesterByInputText(inputText);
  11:                 tester.Start();
  12:  
  13:while (true)
  14:                 {
  15:                     Console.WriteLine(GetStatusOfThreadTester(tester));
  16:if (!tester.IsTesterRunning())
  17:                     {
  18:break;
  19:                     }
  20:                     Thread.Sleep(100);
  21:                 }
  22:  
  23:                 inputText = GetUserChoice();
  24:             }
  25:  
  26:             Console.Write("Click enter to exit...");
  27:         }
  28:  
  29:privatestaticstring GetStatusOfThreadTester(ThreadTester tester)
  30:         {
  31:returnstring.Format("[耗时{0}ms] counter = {1}, {2}",
  32:                     tester.GetElapsedMillisecondsOfIncreaseCounter(), tester.GetCounter(),
  33:                     tester.IsTesterRunning() ? "running" : "stopped");
  34:         }
  35:  
  36:privatestatic ThreadTester GreateThreadTesterByInputText(string inputText)
  37:         {
  38:switch (inputText)
  39:             {
  40:case"1":
  41:returnnew SingleThreadTester();
  42:case"2":
  43:returnnew TwoThreadSwitchTester();
  44:default:
  45:returnnew MultiThreadTester(100);
  46:             }
  47:         }
  48:  
  49:privatestaticstring GetUserChoice()
  50:         {
  51:             Console.WriteLine(@"==Please select the option in the following list:==
  52: 1. SingleThreadTester
  53: 2. TwoThreadSwitchTester
  54: 3. MultiThreadTester
  55: 4. Exit");
  56:  
  57:string inputText = Console.ReadLine();
  58:  
  59:return inputText;
  60:         }
  61:     }

三个测试类，运行结果如下：

Single Thread:
[耗时407ms] counter = 100000001, stopped
[耗时453ms] counter = 100000001, stopped
[耗时412ms] counter = 100000001, stopped

Two Thread Switch:
[耗时161503ms] counter = 100000001, stopped
[耗时164508ms] counter = 100000001, stopped
[耗时164201ms] counter = 100000001, stopped

Multi Threads - 100 Threads:
[耗时3659ms] counter = 100000001, stopped
[耗时3950ms] counter = 100000001, stopped
[耗时3720ms] counter = 100000001, stopped

Multi Threads - 2 Threads:
[耗时3078ms] counter = 100000001, stopped
[耗时3160ms] counter = 100000001, stopped
[耗时3106ms] counter = 100000001, stopped

什么是线程上下文切换

上下文切换的精确定义可以参考: http://www.linfo.org/context_switch.html。多任务系统往往需要同时执行多道作业。作业数往往大于机器的CPU数，然而一颗CPU同时只能执行一项任务，为了让用户感觉这些任务正在同时进行，操作系统的设计者巧妙地利用了时间片轮转的方式，CPU给每个任务都服务一定的时间，然后把当前任务的状态保存下来，在加载下一任务的状态后，继续服务下一任务。任务的状态保存及再加载，这段过程就叫做上下文切换。时间片轮转的方式使多个任务在同一颗CPU上执行变成了可能，但同时也带来了保存现场和加载现场的直接消耗。(Note. 更精确地说, 上下文切换会带来直接和间接两种因素影响程序性能的消耗. 直接消耗包括: CPU寄存器需要保存和加载, 系统调度器的代码需要执行, TLB实例需要重新加载, CPU 的pipeline需要刷掉; 间接消耗指的是多核的cache之间得共享数据, 间接消耗对于程序的影响要看线程工作区操作数据的大小).

技术分享

根据上面上下文切换的定义，我们做出下面的假设：

  1. 之所以TwoThreadSwitchTester执行速度最慢，因为线程上下文切换的次数最多，时间主要消耗在上下文切换了，两个线程交替计数，每计数一次就要做一次线程切换。
  2. “Multi Threads - 100 Threads”比“Multi Threads - 2 Threads”开的线程数量要多，导致线程切换次数也比后者多，执行时间也比后者长。

由于Windows下没有像Linux下的vmstat这样的工具，这里我们使用Process Explorer看看程序执行的时候线程上线文切换的次数。

Single Thread:

技术分享

计数期间，线程总共切换了580-548=32次。（548是启动程序后，初始的数值）

Two Thread Switch:

技术分享

计数期间，线程总共切换了33673295-124=33673171次。（124是启动程序后，初始的数值）

Multi Threads - 100 Threads:

技术分享

计数期间，线程总共切换了846-329=517次。（329是启动程序后，初始的数值）

Multi Threads - 2 Threads:

技术分享

计数期间，线程总共切换了295-201=94次。（201是启动程序后，初始的数值）

从上面收集的数据来看，和我们的判断基本相符。

干活的其实是CPU，而不是线程

再想想原来学过的知识，之前一直以为线程多干活就快，简直是把学过的计算机原理都还给老师了。真正干活的不是线程，而是CPU。线程越多，干活不一定越快。

那么高并发的情况下什么时候适合单线程，什么时候适合多线程呢？

适合单线程的场景：单个线程的工作逻辑简单，而且速度非常快，比如从内存中读取某个值，或者从Hash表根据key获得某个value。Redis和Node.js这类程序都是单线程，适合单个线程简单快速的场景。

适合多线程的场景：单个线程的工作逻辑复杂，等待时间较长或者需要消耗大量系统运算资源，比如需要从多个远程服务获得数据并计算，或者图像处理。

例子程序：http://pan.baidu.com/s/1c05WrGO

参考：

  • Context Switch – Wikipedia
  • 多线程的代价
  • Threading in C#
  • 为什么我要用 Node.js? 案例逐一介绍
  • 知乎——redis是个单线程的程序，为什么会这么快呢？每秒10000？这个有点不解，具体是快在哪里呢？EPOLL？内存？多线程
  • 从Java视角理解系统结构(一)CPU上下文切换

如下是自己写的多线程验证代码：
1.Junit测试类
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;
import java.util.ArrayList;
import org.apache.commons.net.ftp.FTPClient;
import org.junit.Test;
import com.Thread.MyThread;
public class MainTest {
 private int count = 10000;
 private int countTest = 10000;
  //用主线程遍历ArrayList（结论：如果循环中不sleep,速度最快，如果循环中sleep,则遍历速度比多线程慢）
 @Test
 public void test() throws InterruptedException {
  long startTime = System.currentTimeMillis();
  ArrayList<Integer>  testList = new ArrayList<Integer>();
  ArrayList<Integer>  testList1 = new ArrayList<Integer>();
  for(int i=0; i<count; i++){
   testList.add(i);
  }
  for(int j=0; j<countTest; j++){
   testList1.add(j);
  }
 
  System.out.println("testList.size():" + testList.size() + "   i=" + 0);
 
  for(int j=0; j<testList.size(); j++){
   Thread.sleep(2);
   System.out.println(Thread.currentThread().getName() + " ：" + testList.get(j));
  }
 
  for(int jj=0; jj<testList1.size(); jj++){
   Thread.sleep(2);
   System.out.println(Thread.currentThread().getName() + " ：" + testList.get(jj));
  }
 
 
  System.out.println("程序总共花费时间：" + (System.currentTimeMillis()-startTime) + "毫秒");
 }
 
//在主线程中启动一个子线程去遍历ArrayList（结论:在循环中如果不sleep,遍历速度仅次于主线程，如果循环中sleep,速度与主线程遍历差不多）
 @Test
 public void test0() {
  long startTime = System.currentTimeMillis();
  ArrayList<Integer>  testList = new ArrayList<Integer>();
  ArrayList<Integer>  testList1 = new ArrayList<Integer>();
  for(int j=0; j<countTest; j++){
   testList1.add(j);
  }
  for(int i=0; i<count; i++){
   testList.add(i);
  }
  System.out.println("testList.size():" + testList.size() + "   i=" + 0);
 
  Runnable run0 = new MyThread(testList,0, count);
  Thread t0 = new Thread(run0, "Thread-0");
  long startTime1 = System.currentTimeMillis();
  t0.start();
  System.out.println("线程启动时间：" + (System.currentTimeMillis() - startTime1));
  try {
   t0.join();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("程序总共花费时间：" + (System.currentTimeMillis()-startTime) + "毫秒");
 }
  //在主线程中启动两个子线程去遍历ArrayList（结论：如果在循环中不sleep,速度最慢，如果在循环中sleep,则遍历速度最快）
 @Test
 public void test1() {
  long startTime = System.currentTimeMillis();
  ArrayList<Integer>  testList = new ArrayList<Integer>();
  ArrayList<Integer>  testList1 = new ArrayList<Integer>();
 
  for(int i=0; i<count; i++){
   testList.add(i);
  }
 
  for(int j=0; j<countTest; j++){
   testList1.add(j);
  }
  System.out.println("testList.size():" + testList.size() + "   i=" + 0);
 
  Runnable run1 = new MyThread(testList,0, count/2);
  Thread t1 = new Thread(run1, "Thread-1");
  t1.start();
 
  Runnable run2 = new MyThread(testList,(count/2+1), count);
  Thread t2 = new Thread(run2, "Thread-2");
  t2.start();
  try {
   t1.join();
   t2.join();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("程序总共花费时间：" + (System.currentTimeMillis()-startTime) + "毫秒");
 }
  //用单线程从ftp上下载两个文件
 @Test
 public void FileUpload() {
  long startTime = System.currentTimeMillis();
  try {
   FTPClient ftp = new FTPClient();
   ftp.connect("192.168.173.156", 21);
   ftp.login("admin", "123456");
   InputStream in = ftp.retrieveFileStream("ax.java");
   byte[] buffer = new byte[1024];
   while((in.read(buffer))!=-1){
    //System.out.println(Arrays.toString(buffer));
   }
   in.close();
   
   FTPClient ftp1 = new FTPClient();
   ftp1.connect("192.168.173.156", 21);
   ftp1.login("admin", "123456");
   InputStream in1 = ftp1.retrieveFileStream("ay.java");
   byte[] buffer1 = new byte[1024];
   while((in1.read(buffer1))!=-1){
    //System.out.println(Arrays.toString(buffer));
   }
   in1.close();
 
   
  } catch (SocketException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 
  System.out.println("程序总共花费时间：" + (System.currentTimeMillis()-startTime) + "毫秒");
 }
  //用两个线程从ftp上下载两个文件（结论：是多线程下载速度比单线程下载速度快）
 @Test
 public void FileUpload1() {
  long startTime = System.currentTimeMillis();
 
 /* Runnable run1 = new MyThread("ax.java");
  Thread t1 = new Thread(run1, "Thread-1");
  t1.start();
 
  Runnable run2 = new MyThread("ay.java");
  Thread t2 = new Thread(run2, "Thread-2");
  t2.start();
 
  try {
   t1.join();
   t2.join();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("程序总共花费时间：" + (System.currentTimeMillis()-startTime) + "毫秒");*/
 }
}

2、多线程实现类
package com.Thread;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Arrays;
import org.apache.commons.net.ftp.FTPClient;
public class MyThread implements Runnable{
 private ArrayList<Integer> intList = new ArrayList<Integer>();
 private int startNum;
 private int endNum;
 private String filename;
 
 public MyThread(ArrayList<Integer> intList, int startNum, int endNum) {
  super();
  this.intList = intList;
  this.startNum = startNum;
  this.endNum = endNum;
 }
 
 @Override
 public void run() {
  System.out.println("线程"+Thread.currentThread().getName()+"开始启动……");
  System.out.println("intList.size():" + intList.size() + "   startNum=" + startNum + "    endNum=" + endNum);
  for(int m=startNum; m<endNum;m++){
   System.out.println(Thread.currentThread().getName() + " : " + intList.get(m));
   try {
    Thread.sleep(2);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("线程"+Thread.currentThread().getName()+"执行结束……");
 
  /*try {
   FTPClient ftp = new FTPClient();
   ftp.connect("192.168.173.156", 21);
   ftp.login("admin", "123456");
   InputStream in = ftp.retrieveFileStream(filename);
   byte[] buffer = new byte[1024];
   while((in.read(buffer))!=-1){
    //System.out.println(Arrays.toString(buffer));
   }
   in.close();*/
 }
 
 /*public MyThread(String filename) {
  super();
  this.filename = filename;
 }*/
}


多线程为什么跑的比单线程还要慢的情况分析及验证

标签：多线程   性能   效率   编程   java   

原文地址：http://blog.csdn.net/ljj2312/article/details/44206925
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！