由一篇文章引发的思考——多线程处理大数组

最新推荐文章于 2024-12-24 21:43:55 发布
最新推荐文章于 2024-12-24 21:43:55 发布
阅读量130 收藏
点赞数
文章标签： 大数据
原文链接：http://www.cnblogs.com/asdyzh/p/9832455.html
版权

当单线程处理大数组遇到性能瓶颈时应该怎样处理

虽然科技一直在进步，CPU的处理能力也一直在提高，但是当我们进入大数据时代后，CPU每秒钟都会面临着大量的数据需要处理，这个时候CPU的处理能力可能就会成为性能瓶颈。这是我们就要选择多核多CPU了，编程中也就是使用多线程进行处理。

首先看下单线程处理的例子

复制代码 
static void Main(string[] args)
{
    int count = 100000000;
    double[] arrayForTest = new double[count];
    Stopwatch watch = new Stopwatch();
    watch.Start();
    for (int i = 0; i < arrayForTest.Length; i++)
    {
        arrayForTest[i] = MathOperationFunc(arrayForTest[i]);
    }
    watch.Stop();
    Console.WriteLine("经过 " + arrayForTest.Length + " 次循环共消耗时间 " + (watch.ElapsedMilliseconds / 1000.0) + " s");
}

static double MathOperationFunc(double value)
{
    return Math.Sin(Math.Sqrt(Math.Sqrt((double)value * Math.PI)) * 1.01);
}
复制代码

单线程处理的耗时

单线程测试

这个单线程的例子中对一个有10000000个元素的数组中的每个元素进行了数学计算，执行完毕共计耗时5.95秒。

然后看两个线程处理的例子

复制代码 
static void Main(string[] args)
{
    //四线程测试
    int threadCount = 2;
    Thread[] threads = new Thread[threadCount];
    for (int i = 0; i < threadCount; i++)
    {
        threads[i] = new Thread(ForTestInThread);
        threads[i].Name = threadCount + "线程测试" + (i + 1);
        threads[i].Start();
    }
}
//工作线程
static void ForTestInThread()
{
    int count = 50000000;
    double[] arrayForTest = new double[count];
    Stopwatch watch = new Stopwatch();
    watch.Start();
    for (int i = 0; i < arrayForTest.Length; i++)
    {
        arrayForTest[i] = MathOperationFunc(arrayForTest[i]);
    }
    watch.Stop();
    Console.WriteLine("线程：" + Thread.CurrentThread.Name + "，经过 " + arrayForTest.Length + " 次循环共消耗时间 " + (watch.ElapsedMilliseconds / 1000.0) + " s");
}

//数据计算
static double MathOperationFunc(double value)
{
    return Math.Sin(Math.Sqrt(Math.Sqrt((double)value * Math.PI)) * 1.01);
}
复制代码

两个线程测试耗时

双线程测试

我们再来看一下四个线程的例子

复制代码 
static void Main(string[] args)
{
    //四线程测试
    int threadCount = 4;
    Thread[] threads = new Thread[threadCount];
    for (int i = 0; i < threadCount; i++)
    {
        threads[i] = new Thread(ForTestInThread);
        threads[i].Name = threadCount + "线程测试" + (i + 1);
        threads[i].Start();
    }
}
//工作线程
static void ForTestInThread()
{
    int count = 25000000;
    double[] arrayForTest = new double[count];
    Stopwatch watch = new Stopwatch();
    watch.Start();
    for (int i = 0; i < arrayForTest.Length; i++)
    {
        arrayForTest[i] = MathOperationFunc(arrayForTest[i]);
    }
    watch.Stop();
    Console.WriteLine("线程：" + Thread.CurrentThread.Name + "，经过 " + arrayForTest.Length + " 次循环共消耗时间 " + (watch.ElapsedMilliseconds / 1000.0) + " s");
}

//数据计算
static double MathOperationFunc(double value)
{
    return Math.Sin(Math.Sqrt(Math.Sqrt((double)value * Math.PI)) * 1.01);
}
复制代码

四个线程测试耗时

四线程测试

由上面的测试中可以看到，随着线程数的增多，任务被分解后每个线程执行的任务耗时由原来的 6秒 逐渐降到 2秒 左右，由此我们可以猜想当所有线程同时执行的时候，那么总任务的耗时就会下降，接下来让我们来进行更精确的测试。

Thread.Join方法简介

进行多线程测试时，经常会遇到这样的问题：主线程中如何等待所有线程执行结束后，再执行后续任务。

错误的做法

复制代码 
Thread[] threads = new Thread[threadCount];
for (int i = 0; i < threadCount; i++)
{
    int beginIndex = i*arrayForTest.Length/threadCount;
    int length = arrayForTest.Length/threadCount;
    threads[i] = new Thread(WorkerThread);
    var arg = new Tuple<double[], int, int>(arrayForTest, beginIndex, length);
    threads[i].Name = threadCount + "线程测试" + (i + 1).ToString();
    threads[i].Start(arg);
    //等待所有线程结束 
    threads[i].Join();
}
复制代码

这么做实际上所有的子线程均是串行执行的，并没有达到并行的效果。

正确的做法

复制代码 
Thread[] threads = new Thread[threadCount];
for (int i = 0; i < threadCount; i++)
{
    int beginIndex = i*arrayForTest.Length/threadCount;
    int length = arrayForTest.Length/threadCount;
    threads[i] = new Thread(WorkerThread);
    var arg = new Tuple<double[], int, int>(arrayForTest, beginIndex, length);
    threads[i].Name = threadCount + "线程测试" + (i + 1).ToString();
    threads[i].Start(arg);
}
//等待所有线程结束
foreach (var thread in threads)
{
    thread.Join();
}
复制代码

多线程处理大数组的实现

了解了Thread.Join后，就可以进行多线程处理大数组的代码编写了：

复制代码 
class Program
{
    static void Main(string[] args)
    {
        int count = 100000000;
        double[] arrayForTest = new double[count];
        Stopwatch totalWatch = new Stopwatch();
        totalWatch.Start();
        ThreadTest(arrayForTest, 2);
        totalWatch.Stop();
        Console.WriteLine("总任务，经过 " + arrayForTest.Length + " 次循环共消耗时间 " + (totalWatch.ElapsedMilliseconds / 1000.0) + " s");
    }

    //大循环测试
    static void ForTest(double[] arrayForTest, int beingIndex, int offset, Func<double, double> func)
    {
        for (int i = beingIndex; i < beingIndex + offset; i++)
        {
            arrayForTest[i] = func(arrayForTest[i]);
        }
    }

    //数学计算
    static double MathOperationFunc(double value)
    {
        return Math.Sin(Math.Sqrt(Math.Sqrt((double)value * Math.PI)) * 1.01);
    }

    static void ThreadTest(double[] arrayForTest, int threadCount)
    {
        //启动线程
        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++)
        {
            //为每个线程分配任务
            int beginIndex = i*arrayForTest.Length/threadCount;
            int length = arrayForTest.Length/threadCount;
            threads[i] = new Thread(WorkerThread);
            var arg = new Tuple<double[], int, int>(arrayForTest, beginIndex, length);
            threads[i].Name = threadCount + "线程测试" + (i + 1).ToString();
            threads[i].Start(arg);
            threads[i].Join();
        }
        //等待所有线程结束
        foreach (var thread in threads)
        {
            thread.Join();
        }
    }

    //工作线程
    static void WorkerThread(object arg)
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        var argArray = arg as Tuple<double[], int, int>;
        if (argArray == null)
            return;
        ForTest(argArray.Item1, argArray.Item2, argArray.Item3, MathOperationFunc);
        watch.Stop();
        Console.WriteLine("线程：" + Thread.CurrentThread.Name + "，经过 " + argArray.Item3 + " 次循环共消耗时间 " + (watch.ElapsedMilliseconds/1000.0) + " s");
    }
}
复制代码

这样多线程处理大数组的功能代码就编写完成了，那么性能是如何呢，用事实说话，效果如下：

多线程方法测试

由图可以看出，将一个大任务分解到两个线程中去执行后，大任务总体的执行时间会缩短，但是与两个线程中耗时最长的线程的执行时间有关。

同时执行耗时由原来的6秒逐渐降到2秒左右。可见在多核的机器上，多线程是可以提高性能的。

所以当单线程处理大数组遇到性能瓶颈时可以考虑通过多线程来处理。

既然这个多线程处理大数组的功能效果非常好，那么何不把它封装为一个类，添加到自己的类库中，这样就可以随时使用了：

复制代码 
class BigArrayFor
{
    /// <summary>
    /// 执行任务时，使用的线程数
    /// </summary>
    public int ThreadCount { get; set; }

    /// <summary>
    /// 处理大数组中每个元素的方法
    /// </summary>
    public Func<double, double> ForFunc { get; private set; }

    /// <summary>
    /// 需要处理的大数组
    /// </summary>
    public double[] ArrayForTest { get; private set; }

    /// <summary>
    /// 实例化处理大数组的类
    /// </summary>
    /// <param name="arrayForTest">需要处理的大数组</param>
    /// <param name="forFunc">处理大数组中每个元素的方法</param>
    public BigArrayFor(double[] arrayForTest, Func<double, double> forFunc)
    {
        if (arrayForTest == null || forFunc == null)
        {
            throw new ArgumentNullException();
        }
        ThreadCount = 4;
        ForFunc = forFunc;
        ArrayForTest = arrayForTest;
    }

    /// <summary>
    /// 开始处理大数组
    /// </summary>
    public void Run()
    {
        //启动线程
        Thread[] threads = new Thread[ThreadCount];
        for (int i = 0; i < ThreadCount; i++)
        {
            //为每个线程分配任务
            int beginIndex = i * (ArrayForTest.Length / ThreadCount);
            int length = ArrayForTest.Length / ThreadCount;
            threads[i] = new Thread(WorkerThread);
            var arg = new Tuple<double[], int, int>(ArrayForTest, beginIndex, length);
            threads[i].Name = ThreadCount + "线程测试" + (i + 1);
            threads[i].Start(arg);
        }
        //等待所有线程结束
        foreach (var thread in threads)
        {
            thread.Join();
        }
    }

    private void WorkerThread(object arg)
    {
        var argArray = arg as Tuple<double[], int, int>;
        if (argArray == null)
            return;
        ForTest(argArray.Item1, argArray.Item2, argArray.Item3, ForFunc);
    }
    //大循环测试
    private void ForTest(double[] arrayForTest, int beingIndex, int offset, Func<double, double> func)
    {
        for (int i = beingIndex; i < beingIndex + offset; i++)
        {
            arrayForTest[i] = func(arrayForTest[i]);
        }
    }

}
复制代码

好了，大数组循环类完成了，到目前为止，最多也只测试过4个线程同时处理大数组的效果，那么线程数继续增多，是不是执行时间会随之缩短呢，万事俱备，让我们开始更详细的测试吧

复制代码 
static void Main(string[] args)
{

    //多线程操作大数组
    int count = 100000000;
    double[] arrayForTest = new double[count];
    //一个线程
    ThreadTest(arrayForTest, 1);
    //两个线程
    ThreadTest(arrayForTest, 2);
    //四个线程
    ThreadTest(arrayForTest, 4);
    //八个线程
    ThreadTest(arrayForTest, 8);
    //十六个线程
    ThreadTest(arrayForTest, 16);
    //二十五个线程
    ThreadTest(arrayForTest, 25);
    //三十二个线程
    ThreadTest(arrayForTest, 32);
}

static void ThreadTest(double[] arrayForTest, int threadCount)
{
    BigArrayFor bigArrayFor = new BigArrayFor(arrayForTest, MathOperationFunc);
    bigArrayFor.ThreadCount = threadCount;
    Stopwatch totalWatch = new Stopwatch();
    totalWatch.Start();
    bigArrayFor.Run();
    totalWatch.Stop();
    Console.WriteLine(bigArrayFor.ThreadCount + " 个线程，经过 " + arrayForTest.Length + " 次循环，共消耗时间 " + (totalWatch.ElapsedMilliseconds / 1000.0) + " s");
    Console.WriteLine();
}
复制代码

然后看测试效果

多线程_类测试

我们可以看到，随着线程数量的增多，处理数组所需的总体时间并不是随着线性的缩短，这是因为当线程数量超过CPU的核数后，会增加很多的线程调度的时间，当线程超过一定数量后，性能反而会下降。

总结

在多核机器上，当单线程处理大数组遇到性能瓶颈时，可以考虑使用多线程进行处理，但是线程数量要适量，否则会因为线程调度导致性能下降。

 

转自https://www.cnblogs.com/hbccdf/p/csharp_debug_induction.html

转载于:https://www.cnblogs.com/asdyzh/p/9832455.html

后端面试话术集锦第 十六 篇：java锁面试话术
念兮为美
09-03 1273
介绍一下乐观锁和悲观锁；介绍一下公平锁和非公平锁；重入锁（递归锁）和不可重入锁（自旋锁）；共享锁和独占锁；synchronized和threadlocal的区别；ConcurrentHashMap如何实现线程安全；介绍下你理解的线程中的锁；谈谈ReentrantLock、aqs框架，ReentrantLock的重入锁；谈谈Synchronized(重入锁)；为什么说Synchronized是一个悲观锁？乐观锁的实现原理又是什么？什么是CAS，它有什么特性？
后端面试话术集锦第 十三 篇：java集合面试话术
念兮为美
09-01 378
后端面试话术集锦第 十三 篇：java集合面试话术。Java里常见的数据结构都有哪些以及特征；HashMap底层原理；介绍下ConcurrentHashMap；线程安全的HashMap类有哪些，ConcurrentHashMap如何保证线程安全； HashMap1.7与1.8的区别，说明1.8做了哪些优化，如何优化的
死磕 java线程系列之线程的生命周期
彤哥读源码
10-18 1432
（手机横屏看源码更方便） 注：java源码分析部分如无特殊说明均基于 java8 版本。 简介 大家都知道线程是有生命周期，但是彤哥可以认真负责地告诉你网上几乎没有一篇文章讲得是完全正确的。 常见的错误有：就绪状态、运行中状态（RUNNING）、死亡状态、中断状态、只有阻塞没有等待状态、流程图乱画等，最常见的错误就是说线程只有5种状态。 今天这篇文章会彻底讲清楚线程的生命周期，并分析synch...
java 一个包含了2万个整数的数组,多线程来进行并行计算
qq_40285647的博客
06-13 1037
一个包含了2万个整数的数组 计算任务:一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。 数据错误的原因：4个子线程还没有执行完毕，主线程就抢到资源并输出结果 解决方案：4个子线程全部执行完毕，再让主线程抢到资源 1.休眠 Thread.sleep(10); 2.获取线程状态 while(t1.isFlag() || t2.isFlag() || t3.isFlag() || t4.isFlag()){ } 3.合并 ​ t1.join(); ​ t2.join();
20000个整数数组化为为多个线程求和
weixin_42286045的博客
05-15 392
问题描述： 计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。 方法一：采用普通多线程 package com.neo.DivideArray_Sum_MultiThread; /** * @Author Neo * @Description TODO * @Date 2021/5/15 10:40 * @Version 1.0 */ @SuppressWarnings("all") public class Test { public sta
Java多线程经典面试题：编写代码，实现多线程大数组求和的问题（简单实现）
weixin_56610646的博客
11-11 718
如果不是全局的变量，那么在lambda表达式中修改的时候会报错，lambda表达式中不允许修改变量。1.给定一个很长的数组（长度1000w），通过随机数的方式生成1-100之间的整数。3.其中线程1汇总计算偶数下表元素的和，线程2计算汇总奇数下标元素的和。2.实现代码，能够创建两个线程，对这个数组的所有元素求和。方法2：创建两个带有返回值的线程，将这两个返回值累计即可。方法1：我们使用两个不带有返回值的线程，这样我们就需要。4.最终在汇总两个和，进行相加。5.记录程序的执行时间。
【多线程高并发】-多线程实现数组的读与写
Mind_programmonkey的博客
04-17 1567
多线程下实现数组的读与写，用到的是Java的copyOnWriteArrayList数组，具体其有关的解释，可看往期的 package com.lcz.thread; import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.ExecutorService; imp
Python 爬虫进阶篇——多线程
th1522856954的博客
07-21 535
本文介绍一下多线程。不过值得注意的是，不能滥用多线程，多线程爬虫请求内容速度过快，可能会导致服务器过载，或者是IP被封禁。为了避免这一问题，我们在使用多线程爬虫的时候需要设置一个delay时间，用于请求同一域名时的最小时间间隔。 线程和进程如何工作 当程序在运行时，就会创建包含代码和状态的进程。这些进程通过一个或者多个CPU来执行。不过同一时刻每个CPU只会执行一个进程，然后在不同进程之间快速切换，这样就感觉多个程序同时运行。同理，在一个进程中，程序的执行也是在不同线程间进行切换的，每个线程执行程序..
Java——深入理解多线程中的锁
weixin_41438466的博客
10-03 334
前言 在Java并发编程中锁的知识是必备的，所以如果在做并发项目的话，这篇文章或多或少都会给你一些想要的，本文主要从概念思想来深入理解Java中的锁，当然如果想要看代码实现的可以在下面这篇文章中查阅 《Java锁详解——lock的实现》 1. 整体了解Java多线程中的锁 看下面这张图片我们可以大体了解锁的种类 接下来对各种锁进行详细说明 2. 悲观锁和乐观锁 这两种主要是看开发人员对线程安全...
Kotlin学习篇（1）—— Kotlin的基础常识
haazzz的博客
04-20 1201
目录1. Kotlin的优缺点2. 在java项目添加Kotlin支持3. if的使用4. 表达式函数体5. 变量6. 字符串模板7. when8. is的使用9. 迭代10. “in”和“!in”的使用 1. Kotlin的优缺点 Kotlin的优势： Kotlin更安全： Kotlin 支持显式地声明 null，并确保开发人员不会遇到可能导致质量问题的空引用异常； 代码简洁：不需要分号、很多相同的功能去用Kotlin实现语法更简洁 函数式支持： 高阶函数 扩展函数：可以直接不需要修改
请输入一个数字M，计算1-2+3-4+5.......M.
打酱油的男神
03-21 3565
三种实现方式以及速度对比： /// &lt;summary&gt; /// 第一种 /// &lt;/summary&gt; /// &lt;param name="m"&gt;&lt;/param&gt; /// &lt;returns&gt;&lt;/returns&gt; static int GetSum(
《多线程总结篇》《多线程向一个数组里面添加数据》
qq_39773004的博客
06-17 1100
一、基础 1.线程实现的三种方式 1.继承Thread类 2.实现Runnable接口 3.实现callable接口 2.线程停止stop()、线程休眠sleep()、线程礼让yield()、线程插队join() 3.线程的5大状态getState() 1.新建 2.就绪 3.运行 4.阻塞 5.死亡 4.线程的优先级getPriority()、setPriority() 设置优先级增加在cpu那里的权重 5.用户线程、守护线程 用户线程：main() 守护线程：gc() 虚拟机必须确保用户线程执行完毕，不
理解线程/多线程处理数组(MultiThreaded dealing with arrays)
惊鸿一博
05-27 5797
1、理解线程 　　要讲解线程，不得不说一下进程，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。线程的基本思想很简单，它是一个独立的执行流，是进程内部的一个独立的执行单元，相当于一个子程序，它对应于Visual C++中的CwinThread类对象。单独一个执行程序运行时，缺省地包含的一个主线程，主线程以函数地址
线程内定义数组过大导致segmentation fault段错误：
oywoywoyw的专栏
09-02 2622
<br />  编写linux多线程程序时，在线程内分配超过10M的栈空间后编译通过但运行时出现segmentation falut段错误，网上查了下线程的栈大小大概为8M。
一篇文章总结了JVM线程基本原理
读书就是赚钱
07-10 2395
最近开发了一个文件同步助手，用的是生产者消费者模式，用线程池初始化3条线程做自定义文件生成操作，用一条线程去处理第一步完成的结果Future，利用几天的时间结合项目，站在JVM的角度回顾JAVA线程的相关知识，接下去再整一篇线程安全的，之前写的多线程还是在一年以前，再次回顾受益匪浅 一、JAVA内存模型与线程 1 CPU工作效率比IO工作效率大 1.1 为什么 计算机的存储...
java 多线程数组_Java多线程基础
weixin_39568232的博客
02-12 848
一、程序，进程，线程等相关概念的理解程序是指未完成指定任务，用某种语言编写的一段代码指令的集合，即指一段静态的代码。进程是程序的一次执行过程，可以理解为正在执行的一个程序。(进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域)进程进一步细分为线程，是程序内部的一条执行路径。(线程作为调度和执行的单位，线程之间的切换开销小)每个线程都拥有自己独立的栈和程序计数器多个线程会共享同一个进...
多个线程操作数组
小布1994的博客
10-26 6141
package Thread; import org.apache.commons.lang3.ArrayUtils; import java.util.ArrayList; import java.util.List; /** * @author xiaobu * @version JDK1.8.0_171 * @date on 2018/10/19 9:13 * @descrp...
包含了2万个整数的数组，用多个线程来进行并行和计算，最后汇总出计算的结果。
Like_up的博客
06-13 1560
利用多线程对2万个整数的数组计算和，并得到结果。 具体问题 计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。 多线程的创建方式 Thread类，自己创建一个类继承Thread类，通过创建对象。 Runnable接口，自己创建一个类实现Runnable接口。 方法一：Thread类 方法二：Runnable接口 我们通过三种方法（睡眠、合并、判断）来解决线程间抢资源的问题，会发现， 睡眠：Thread.sleep(1000（1秒）//延迟的时间)：这...
Kafka 都有哪些特点？
最新发布
pxyxyxy的博客
12-24 432
Kafka 有一个活跃的社区和丰富的生态系统，与许多其他系统和工具（如 Hadoop、Spark、Flink 等）集成。：Kafka 提供了 Kafka Streams API，允许用户在 Kafka 集群上直接进行流处理。：Kafka 支持多租户，可以通过不同的主题（Topics）来隔离不同的数据流。：除了流处理，Kafka 也支持批处理和微批处理，以满足不同的数据处理需求。：Kafka 将消息持久化到磁盘，并支持数据副本，确保数据的可靠性。：Kafka 能够处理大量的数据，每秒可以处理数十万条消息。
C#深度解析：多线程实战——I/O线程与异步操作
本文深入探讨了C#多线程编程的各个方面，首先从基础概念开始...本篇内容深入剖析了C#多线程编程的关键技术，涵盖了从基础概念到高级应用的广泛范围，对提升开发者在处理并发问题时的效率和代码可维护性具有很高的价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>