问：多线程是不是能加快处理速度？

解析：

在使用多线程时，一定要知道一个道理：处理速度的最终决定因素是CPU、内存等，在单CPU（无论多少核）上，分配CPU资源的单位是“进程”而不是“线程”。

我们可以做一个简单的试验：

假设我要拷贝100万条数据，单CPU电脑，用一个进程，在单线程的情况下，CPU占用率为5%，耗时1000秒。那么当在这个进程下，开辟10个线程同时去运行，是不是CPU占用率增加到50%，耗时减少到100秒呢？显然不是。我实测出来的情况是这样的：

“CPU占用率仍然是5%，总耗时仍然是1000秒。且每个线程的运行时间也为1000秒。”

重点是后面那句，怎么理解？意味着什么？

我的理解如下：进程只有一个，所以分配的CPU资源是一定的，多线程只不过是轮流抢占CPU而已，并不会真正提高处理速度。这意味着，多线程的作用主要在于提高了并发数量，比如http请求，如果是单线程，一次只能接收一个请求，多线程则可以同时接收多个请求。

但是多线程由于轮换使用CPU，会造成单个线程的执行速度变慢（以前CPU供一个线程使用，现在要供多个线程轮流使用了）。但是在多CPU的服务器上，多线程就很有优势了，它不但能提高并发数量，而且能提高处理速度。因为在多CPU的服务器上，CPU调度很灵活，当一个线程占用着一个CPU的时候，其他线程可以被分配给其他CPU去处理，从而实现了“真正意义上地并行”。

总结：

第一，看硬件。如果是在比较强大的、多CPU的服务器上运行程序，可以使用多线程来提高并发数和执行速度。但是线程也不宜过多，即使是16个CPU的服务器，同一时间最多也只能真正意义上地并发处理16个线程，多出来的线程还是要等待。

第二，看用途。如果你不在乎处理速度，仅仅是为了提高并发处理能力，那么理所当然地用多线程，但是如果你仅仅是想提高处理速度，且又是在单CPU机器上运行，那么多线程并不值得。如果你的任务很耗时，且可以一部分、一部分地做，那么最好不要用多线程（好比搬砖，单线程一次搬10块，总共搬10天，但搬一块算一块，到第9天的时候，你就搬完90块砖了；如果你用10个线程同时去搬砖，同样要搬10天，但是到第9天的时候，这10个线程100块砖都“还在路上”，一块砖都没搬完！）。

一个实际例子

在单线程的情况下，假如说我们生成10个报表文件需要1个小时。

如果是在多线程的情况下呢，生成10个文件要多少个小时？

同样要1个小时。不管你有多少个线程，就算你有100个线程，一样需要1个小时。

这就是问题所在。单线程和多线程的区别在哪里？

单线程是先执行完第一个报表，用了6分钟，再执行第二个报表，也用6分钟。

多线程，是10个报表一起执行，但是每一个报表都要1个小时。

同一个线程，比如说一个servlet，一个人去访问，执行它，只需要2秒。

如果两个人同时去访问，可能就要4秒。如果10个人同时去访问，那么每个人就要

等待20秒。就是说它基本上是一个成倍的线性增长。

一个线程占2%的CPU，那是不是50个线程就占100%的CPU？不是。

50个线程仍然占2%的CPU，分配CPU资源的单位是进程，而不是线程。

所以说线程是无法加快执行速度的

多线程的总体执行时间和单线程是一样的，但是多线程单个线程的执行时间

是单线程的多倍。

我这里有一组数据，我有两个任务，如果是单线程。

先执行任务1，再执行任务2，一共用了80秒钟，每个任务花费40秒

如果我用2个线程同时跑，一共也用了80秒，但是每个任务都花费80秒（也就是说在最后一刻的时候，两个任务几乎是同时完成）。

附：以下两组数据是单线程和多线程耗时的对比（win7系统、笔记本i7 CPU）。

 单位：毫秒

从上面数据可见，2个线程同时运行的时间，几乎等于线程1+线程2单独运行的时间。所以说多线程实际上总时间没变，但是单个任务的执行时间延长了。

我的测试：

463600条数据模拟银行账户转账：

使用的数据：10 25 2500：表示将2500元从账号10转到了账号25。

代码 下载地址：https://download.csdn.net/download/qq_36396104/10852122

前言

Python语言的标准实现叫作CPython，它分两步来运行Python程序

• 步骤1：解析源代码文本，并将其编译成字节码（bytecode）
  • 字节码是一种底层代码，可以把程序表示成8位的指令
  • 从Python 3.6开始，这种底层代码实际上已经变成16位了
• 步骤2：CPython采用基于栈的解释器来运行字节码。
  • 字节码解释器在执行Python程序的过程中，必须确保相关的状态不受干扰，
  • CPython会用一种叫作全局解释器锁（global interpreter lock，GIL）的机制来实现运行的python程序的相关状态不受干扰

GIL

• GIL实际上就是一种互斥锁（mutual-exclusion lock，mutex），用来防止CPython的状态在抢占式的多线程环境（preemptive multithreading）之中受到干扰，因为在这种环境下，一条线程有可能突然打断另一条线程抢占程序的控制权。如果这种抢占行为来得不是时候，那么解释器的状态（例如为垃圾回收工作而设立的引用计数等）就会遭到破坏。
• CPython要通过GIL阻止这样的动作，以确保它自身以及它的那些C扩展模块能够正确地执行每一条字节码指令。
• GIL会产生一个很不好的影响。在C++与Java这样的语言里面，如果程序之中有多个线程能够分头执行任务，那么就可以把CPU的各个核心充分地利用起来。尽管Python也支持多线程，但这些线程受GIL约束，所以每次或许只能有一条线程向前推进，而无法实现多头并进。
• 所以，想通过多线程做并行计算或是给程序提速的开发者，恐怕要失望了。
  • 并发 concurrency : 指计算机似乎能在同一时刻做许多不同的事情
  • 并行 parallelism : 指计算机确实能够在同一时刻做许多不同的事情

多线程下的线程执行

1. 获取GIL
2. 执行代码直到sleep或者是 python虚拟机将其挂起。
3. 释放 GIL

多线程效率低于单线程原因

• 如上我们可以知道，在 python中想要某个线程要执行必须先拿到 GIL这把锁，且 python只有一个 GIL，拿到这个 GIL才能进入 CPU执行， 在遇到 I/O操作时会释放这把锁。如果是纯计算的程序，没有 I/O 操作，解释器会每隔 100次操作就释放这把锁，让别的线程有机会 执行（这个次数可以通sys.setcheckinterval来调整）。所以虽然 CPython 的线程库直接封装操作系统的原生线程，但 CPython 进程做为一个整体，同一时间只会有一个获得了 GIL 的线程在跑，其它的线程都处于等待状态等着 GIL 的释放。
• 而每次释放 GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于 GIL锁存在，python里一个进程永远只能同时执行一个线程 (拿到 GIL的线程才能执行 )，这就是为什么在多核 CPU上， python的多线程效率并不高

多线程效率低于或高于单线程原因

• 相同的代码，为何有时候多线程会比单线程慢，有时又会比单线程快？ 这主要跟运行的代码有关：
• CPU密集型代码(各种循环处理、计数等等 )，在这种情况下，由于计算工作多， ticks计数很快就会达到 100阈值，然后触发 GIL的释放与再竞争 （多个线程来回切换当然是需要消耗资源的），所以 python下的多线程遇到 CPU密集型代码时，单线程比多线程效率高。
• IO密集型代码 (文件处理、网络爬虫等 )，多线程能够有效提升效率单线程下有 IO操作会进行 IO等待，造成不必要的时间浪费。开启多线程能在线程 A等待时，自动切换到线程 B，可以不浪费 CPU的资源，从而能提升程序执行效率 。进行IO密集型的时候可以进行分时切换 所有这个时候多线程快过单线程

如果 python想充分利用多核 CPU，可以采用多进程

• 每个进程有各自独立的 GIL，互不干扰，这样就可以真正意义上的并行执行。
  在 python中，多进程的执行效率优于多线程 (仅仅针对多核 CPU而言 )。所以在多核 CPU下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率

代码示例：

# 多线程
# 最后完成的线程的耗时
# [TIME MEASURE] execute function: gene_1000_field took 3840.604ms
@time_measure
def mult_thread(rows):
    # 总行数
    rows = rows
    # 线程数
    batch_size = 4
    cell = math.ceil(rows / batch_size)
    # 处理数据生成
    print('数据生成中，线程数:' + str(batch_size))
    threads = []
    for i in range(batch_size):
        starts = i * cell
        ends = (i + 1) * cell
        file = f"my_data_{str(i)}.csv"
        # t = threading.Thread(target=gene_1000_field_test, args=(starts, ends, file))
        t = threading.Thread(target=gene_1000_field, args=(starts, ends, file))
        t.start()
        threads.append(t)
    # for t in threads:
    #     t.join()

# 多进程
# [TIME MEASURE] execute function: gene_1000_field took 1094.776ms
# 执行时间和单个线程的执行时间差不多，目的达到
@time_measure
def mult_process(rows):
    # 总行数
    rows = rows
    # 线程数
    batch_size = 4
    cell = math.ceil(rows / batch_size)
    # 处理数据生成
    print('数据生成中，线程数:' + str(batch_size))
    process = []
    for i in range(batch_size):
        starts = i * cell
        ends = (i + 1) * cell
        file = f"my_data_{str(i)}.csv"
        # p = Process(target=f, args=('bob',))
        # p.start()
        # p_lst.append(p)
        # t = threading.Thread(target=gene_1000_field_test, args=(starts, ends, file))
        p = Process(target=gene_1000_field, args=(starts, ends, file))
        p.start()
        process.append(p)

参考文章：

1. https://www.cnblogs.com/caopeiyang/p/9418897.html
2. https://www.cnblogs.com/nickchen121/p/11130256.html

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

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

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

public abstract class ThreadTester {
    public const long MAX_COUNTER_NUMBER = 100000000;
    private long _counter = 0;

    //获得计数
    public long GetCounter() {
        return this._counter;
    }
    //增加计数器
    protected  void IncreaseCounter() {
        this._counter += 1;
    }
    //启动测试
    public abstract void Start();

    //获得Counter从开始增加到现在的数字所耗的时间
    public abstract long GetElapsedMillisecondsOfIncreaseCounter();
    
    //测试是否正在运行
    public abstract bool IsTesterRunning();
}

SingleThreadTester是单线程计数。

class SingleThreadTester :ThreadTester
{
    private Stopwatch _aStopWatch=new Stopwatch();
    
    public override void Start()
    {
        _aStopWatch.Start();
        Thread aThread=new Thread(()=>WorkInThread());
        aThread.Start();
    }
    public override long GetElapsedMillisecondsOfIncreaseCounter()
    {
         return this._aStopWatch.ElapsedMilliseconds;
    }

    public override bool IsTesterRunning()
    {
         return _aStopWatch.IsRunning;
    }

    private void WorkInThread()
    {
        while(true)
        {
            if(this.GetCounter()>ThreadTester.MAX_COUNTER_NUMBER)
            {
                _aStopWatch.Stop();
                break;
            }
            this.IncreaseCounter();
        }
    }
}

TwoThreadSwitchTester是两个线程交替计数。

class TwoThreadSwitchTester : ThreadTester
{
    private Stopwatch _aStopWatch = new Stopwatch();
    private AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
    
    public override void Start()
    {
        _aStopWatch.Start();

        Thread aThread1 = new Thread(() => Work1InThread());
        aThread1.Start();
        
        Thread aThread2 = new Thread(() => Work2InThread());
        aThread2.Start();
    }

    public override long GetElapsedMillisecondsOfIncreaseCounter()
    {
        return this._aStopWatch.ElapsedMilliseconds;
    }
     
    public override bool IsTesterRunning()
    {
        return _aStopWatch.IsRunning;
    }
     
    private void Work1InThread()
    {
        while (true)
        {
            _autoResetEvent.WaitOne();
            this.IncreaseCounter();
            if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
            {
                _aStopWatch.Stop();
                break;
            }
            _autoResetEvent.Set();
        }
    }

    private void Work2InThread()
    {
        while (true)
        {
            _autoResetEvent.Set();
            _autoResetEvent.WaitOne();
            this.IncreaseCounter();

            if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
            {
                _aStopWatch.Stop();
                break;
            }
        }
    }
}

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

class MultiThreadTester : ThreadTester
{
    private Stopwatch _aStopWatch = new Stopwatch();
    private readonly int _threadCount = 0;
    private readonly object _counterLock = newobject();

    public MultiThreadTester(int threadCount)
    {
        this._threadCount = threadCount;
    }

    public override void Start()
    {
        _aStopWatch.Start();
        for (int i = 0; i < _threadCount; i++)
        {
            Thread aThread = new Thread(() => WorkInThread());
            aThread.Start();
        }
    }

    public override long GetElapsedMillisecondsOfIncreaseCounter()
    {
        return this._aStopWatch.ElapsedMilliseconds;
    }

    public override bool IsTesterRunning()
    {
        return _aStopWatch.IsRunning;
    }
     
    private void WorkInThread()
    {
        while (true)
        {
            lock (_counterLock)
            {
                if (this.GetCounter() > ThreadTester.MAX_COUNTER_NUMBER)
                {
                    _aStopWatch.Stop();
                    break;
                }
                 
                this.IncreaseCounter();
            }
        }
    }
}

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

import java.io.Console;

class Program
{
    static void Main(string[] args)
    {

        string inputText = GetUserChoice();

        while (!"4".Equals(inputText))
        {
            ThreadTester tester = GreateThreadTesterByInputText(inputText);
            tester.Start();
 
            while (true)
            {
                Console.WriteLine(GetStatusOfThreadTester(tester));
                if (!tester.IsTesterRunning())
                {
                    break;
                }
                Thread.Sleep(100);
            }
 
            inputText = GetUserChoice();
        }
 
        Console.Write("Click enter to exit...");
    }
 
    private static string GetStatusOfThreadTester(ThreadTester tester)
    {
        return string.Format("[耗时{0}ms] counter = {1}, {2}",
                tester.GetElapsedMillisecondsOfIncreaseCounter(), tester.GetCounter(),
                tester.IsTesterRunning() ? "running" : "stopped");
    }
 
    private static ThreadTester GreateThreadTesterByInputText(string inputText)
{
    switch (inputText)
    {
        case"1":
            return new SingleThreadTester();
        case"2":
            return new TwoThreadSwitchTester();
        default:
            return new MultiThreadTester(100);
    }
}
 
    private static string GetUserChoice()
    {
        Console.WriteLine(@"==Please select the option in the following list:==
        1. SingleThreadTester
        2. TwoThreadSwitchTester
        3. MultiThreadTester
        4. Exit");
 
        string inputText = Console.ReadLine();
 
        return inputText;
    }
}

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

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;

 }*/

}

请关注我微信公众号：