C#并行编程-并发集合 - 释迦苦僧 - 博客园

最新推荐文章于 2024-02-09 15:42:29 发布
最新推荐文章于 2024-02-09 15:42:29 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： 随性笔记 转载 文章标签： c#并行编程

基于任务的程序设计、命令式数据并行和任务并行都要求能够支持并发更新的数组、列表和集合。

在.NET Framework 4 以前，为了让共享的数组、列表和集合能够被多个线程更新，需要添加复杂的代码来同步这些更新操作。

如您需要编写一个并行循环，这个循环以无序的方式向一个共享集合中添加元素，那么必须加入一个同步机制来保证这是一个线程安全的集合。

System.Collenctions和System.Collenctions.Generic 名称空间中所提供的经典列表、集合和数组的线程都不是安全的，不能接受并发请求，因此需要对相应的操作方法执行串行化。

下面看代码，代码中并没有实现线程安全和串行化：

class Program
  {
    private static object o = new object();
    private static List<Product> _Products { get; set; }
    /*  coder:释迦苦僧  
     *  代码中 创建三个并发线程 来操作_Products 集合
     *  System.Collections.Generic.List 这个列表在多个线程访问下，不能保证是安全的线程，所以不能接受并发的请求，我们必须对ADD方法的执行进行串行化
     */
    static void Main(string[] args)
    {
      _Products = new List<Product>();
      /*创建任务 t1  t1 执行 数据集合添加操作*/
      Task t1 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t2  t2 执行 数据集合添加操作*/
      Task t2 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t3  t3 执行 数据集合添加操作*/
      Task t3 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      Task.WaitAll(t1, t2, t3);
      Console.WriteLine(_Products.Count);
      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddProducts()
    {
      Parallel.For(0, 1000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        _Products.Add(product);
      });

    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

代码中开启了三个并发操作，每个操作都向集合中添加1000条数据，在没有保障线程安全和串行化的运行下，实际得到的数据并没有3000条，结果如下：

为此我们需要采用Lock关键字，来确保每次只有一个线程来访问  _Products.Add(product); 这个方法，代码如下：

class Program
  {
    private static object o = new object();
    private static List<Product> _Products { get; set; }
    /*  coder:释迦苦僧  
     *  代码中 创建三个并发线程 来操作_Products 集合
     *  System.Collections.Generic.List 这个列表在多个线程访问下，不能保证是安全的线程，所以不能接受并发的请求，我们必须对ADD方法的执行进行串行化
     */
    static void Main(string[] args)
    {
      _Products = new List<Product>();
      /*创建任务 t1  t1 执行 数据集合添加操作*/
      Task t1 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t2  t2 执行 数据集合添加操作*/
      Task t2 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t3  t3 执行 数据集合添加操作*/
      Task t3 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      Task.WaitAll(t1, t2, t3);
      Console.WriteLine("当前数据量为：" + _Products.Count);
      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddProducts()
    {
      Parallel.For(0, 1000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        lock (o)
        {
          _Products.Add(product);
        }
      });

    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

但是锁的引入，带来了一定的开销和性能的损耗，并降低了程序的扩展性，在并发编程中显然不适用。

System.Collections.Concurrent

.NET Framework 4提供了新的线程安全和扩展的并发集合，它们能够解决潜在的死锁问题和竞争条件问题，因此在很多复杂的情形下它们能够使得并行代码更容易编写，这些集合尽可能减少需要使用锁的次数，从而使得在大部分情形下能够优化为最佳性能，不会产生不必要的同步开销。

需要注意的是：

线程安全并不是没有代价的，比起System.Collenctions和System.Collenctions.Generic命名空间中的列表、集合和数组来说，并发集合会有更大的开销。因此，应该只在需要从多个任务中并发访问集合的时候才使用并发几个，在串行代码中使用并发集合是没有意义的，因为它们会增加无谓的开销。

为此，在.NET Framework中提供了System.Collections.Concurrent新的命名空间可以访问用于解决线程安全问题，通过这个命名空间能访问以下为并发做好了准备的集合。

1.BlockingCollection 与经典的阻塞队列数据结构类似，能够适用于多个任务添加和删除数据，提供阻塞和限界能力。

2.ConcurrentBag 提供对象的线程安全的无序集合

3.ConcurrentDictionary  提供可有多个线程同时访问的键值对的线程安全集合

4.ConcurrentQueue   提供线程安全的先进先出集合

5.ConcurrentStack   提供线程安全的后进先出集合

这些集合通过使用比较并交换和内存屏障等技术，避免使用典型的互斥重量级的锁，从而保证线程安全和性能。

ConcurrentQueue 

ConcurrentQueue 是完全无锁的，能够支持并发的添加元素，先进先出。下面贴代码，详解见注释：

class Program
  {
    private static object o = new object();
    /*定义 Queue*/
    private static Queue<Product> _Products { get; set; }
    private static ConcurrentQueue<Product> _ConcurrenProducts { get; set; }
    /*  coder:释迦苦僧  
     *  代码中 创建三个并发线程 来操作_Products 和 _ConcurrenProducts 集合，每次添加 10000 条数据 查看 一般队列Queue 和 多线程安全下的队列ConcurrentQueue 执行情况
     */
    static void Main(string[] args)
    {
      Thread.Sleep(1000);
      _Products = new Queue<Product>();
      Stopwatch swTask = new Stopwatch();
      swTask.Start();

      /*创建任务 t1  t1 执行 数据集合添加操作*/
      Task t1 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t2  t2 执行 数据集合添加操作*/
      Task t2 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t3  t3 执行 数据集合添加操作*/
      Task t3 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });

      Task.WaitAll(t1, t2, t3);
      swTask.Stop();
      Console.WriteLine("List<Product> 当前数据量为：" + _Products.Count);
      Console.WriteLine("List<Product> 执行时间为：" + swTask.ElapsedMilliseconds);

      Thread.Sleep(1000);
      _ConcurrenProducts = new ConcurrentQueue<Product>();
      Stopwatch swTask1 = new Stopwatch();
      swTask1.Start();

      /*创建任务 tk1  tk1 执行 数据集合添加操作*/
      Task tk1 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });
      /*创建任务 tk2  tk2 执行 数据集合添加操作*/
      Task tk2 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });
      /*创建任务 tk3  tk3 执行 数据集合添加操作*/
      Task tk3 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });

      Task.WaitAll(tk1, tk2, tk3);
      swTask1.Stop();
      Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
      Console.WriteLine("ConcurrentQueue<Product> 执行时间为：" + swTask1.ElapsedMilliseconds);
      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddProducts()
    {
      Parallel.For(0, 30000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        lock (o)
        {
          _Products.Enqueue(product);
        }
      });

    }
    /*执行集合数据添加操作*/
    static void AddConcurrenProducts()
    {
      Parallel.For(0, 30000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        _ConcurrenProducts.Enqueue(product);
      });

    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

需要注意的是，代码中的输出时间并不能够完全正确的展示出并发代码下的ConcurrentQueue性能，采用ConcurrentQueue在一定程度上也带来了损耗，如下图所示：

ConcurrentQueue 还有另外两种方法：TryDequeue  尝试移除并返回 和 TryPeek 尝试返回但不移除，下面贴代码：

class Program
  {
    private static object o = new object();
    private static ConcurrentQueue<Product> _ConcurrenProducts { get; set; }
    /*  coder:释迦苦僧  
     *  ConcurrentQueue  下的 TryPeek 和 TryDequeue
     */
    static void Main(string[] args)
    {
      _ConcurrenProducts = new ConcurrentQueue<Product>();
      /*执行添加操作*/
      Console.WriteLine("执行添加操作");
      Parallel.Invoke(AddConcurrenProducts, AddConcurrenProducts);
      Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
      /*执行TryPeek操作   尝试返回不移除*/
      Console.WriteLine("执行TryPeek操作   尝试返回不移除");
      Parallel.Invoke(PeekConcurrenProducts, PeekConcurrenProducts);
      Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);

      /*执行TryDequeue操作  尝试返回并移除*/
      Console.WriteLine("执行TryDequeue操作  尝试返回并移除");
      Parallel.Invoke(DequeueConcurrenProducts, DequeueConcurrenProducts);
      Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);

      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddConcurrenProducts()
    {
      Parallel.For(0, 100, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        _ConcurrenProducts.Enqueue(product);
      });
    }
    /*尝试返回 但不移除*/
    static void PeekConcurrenProducts()
    {
      Parallel.For(0, 2, (i) =>
      {
        Product product = null;
        bool excute = _ConcurrenProducts.TryPeek(out product);
        Console.WriteLine(product.Name);
      });
    }
    /*尝试返回 并 移除*/
    static void DequeueConcurrenProducts()
    {
      Parallel.For(0, 2, (i) =>
      {
        Product product = null;
        bool excute = _ConcurrenProducts.TryDequeue(out product);
        Console.WriteLine(product.Name);
      });
    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

需要注意 TryDequeue  和  TryPeek 的无序性，在多线程下

ConcurrentStack   是完全无锁的，能够支持并发的添加元素，后进先出。下面贴代码，详解见注释：

private static object o = new object();
    /*定义 Stack*/
    private static Stack<Product> _Products { get; set; }
    private static ConcurrentStack<Product> _ConcurrenProducts { get; set; }
    /*  coder:释迦苦僧  
     *  代码中 创建三个并发线程 来操作_Products 和 _ConcurrenProducts 集合，每次添加 30000 条数据 查看 一般Stack 和 多线程安全下的 ConcurrentStack 执行情况
     */
    static void Main(string[] args)
    {
      Thread.Sleep(1000);
      _Products = new Stack<Product>();
      Stopwatch swTask = new Stopwatch();
      swTask.Start();

      /*创建任务 t1  t1 执行 数据集合添加操作*/
      Task t1 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t2  t2 执行 数据集合添加操作*/
      Task t2 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });
      /*创建任务 t3  t3 执行 数据集合添加操作*/
      Task t3 = Task.Factory.StartNew(() =>
      {
        AddProducts();
      });

      Task.WaitAll(t1, t2, t3);
      swTask.Stop();
      Console.WriteLine("List<Product> 当前数据量为：" + _Products.Count);
      Console.WriteLine("List<Product> 执行时间为：" + swTask.ElapsedMilliseconds);

      Thread.Sleep(1000);
      _ConcurrenProducts = new ConcurrentStack<Product>();
      Stopwatch swTask1 = new Stopwatch();
      swTask1.Start();

      /*创建任务 tk1  tk1 执行 数据集合添加操作*/
      Task tk1 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });
      /*创建任务 tk2  tk2 执行 数据集合添加操作*/
      Task tk2 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });
      /*创建任务 tk3  tk3 执行 数据集合添加操作*/
      Task tk3 = Task.Factory.StartNew(() =>
      {
        AddConcurrenProducts();
      });

      Task.WaitAll(tk1, tk2, tk3);
      swTask1.Stop();
      Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
      Console.WriteLine("ConcurrentStack<Product> 执行时间为：" + swTask1.ElapsedMilliseconds);
      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddProducts()
    {
      Parallel.For(0, 30000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        lock (o)
        {
          _Products.Push(product);
        }
      });

    }
    /*执行集合数据添加操作*/
    static void AddConcurrenProducts()
    {
      Parallel.For(0, 30000, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        _ConcurrenProducts.Push(product);
      });

    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

ConcurrentStack 还有另外两种方法：TryPop 尝试移除并返回 和 TryPeek 尝试返回但不移除，下面贴代码：

class Program
  {
    private static object o = new object();
    private static ConcurrentStack<Product> _ConcurrenProducts { get; set; }
    /*  coder:释迦苦僧  
     *  ConcurrentQueue  下的 TryPeek 和 TryPop
     */
    static void Main(string[] args)
    {
      _ConcurrenProducts = new ConcurrentStack<Product>();
      /*执行添加操作*/
      Console.WriteLine("执行添加操作");
      Parallel.Invoke(AddConcurrenProducts, AddConcurrenProducts);
      Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
      /*执行TryPeek操作   尝试返回不移除*/
      Console.WriteLine("执行TryPeek操作   尝试返回不移除");
      Parallel.Invoke(PeekConcurrenProducts, PeekConcurrenProducts);
      Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);

      /*执行TryDequeue操作  尝试返回并移除*/
      Console.WriteLine("执行TryPop操作  尝试返回并移除");
      Parallel.Invoke(PopConcurrenProducts, PopConcurrenProducts);
      Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);

      Console.ReadLine();
    }

    /*执行集合数据添加操作*/
    static void AddConcurrenProducts()
    {
      Parallel.For(0, 100, (i) =>
      {
        Product product = new Product();
        product.Name = "name" + i;
        product.Category = "Category" + i;
        product.SellPrice = i;
        _ConcurrenProducts.Push(product);
      });
    }
    /*尝试返回 但不移除*/
    static void PeekConcurrenProducts()
    {
      Parallel.For(0, 2, (i) =>
      {
        Product product = null;
        bool excute = _ConcurrenProducts.TryPeek(out product);
        Console.WriteLine(product.Name);
      });
    }
    /*尝试返回 并 移除*/
    static void PopConcurrenProducts()
    {
      Parallel.For(0, 2, (i) =>
      {
        Product product = null;
        bool excute = _ConcurrenProducts.TryPop(out product);
        Console.WriteLine(product.Name);
      });
    }
  }

  class Product
  {
    public string Name { get; set; }
    public string Category { get; set; }
    public int SellPrice { get; set; }
  }
View Code

HI阡陌
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模拟多线程并发,給DB插入百万条数据。
weixin_43186788的博客
09-04 164
1.通过可变参数向数据库中插入数据。2.模拟多线程并发插入数据。
C# 并行计算示例
11-03
并行计算示例,演示了Parallel.Invoke()并行任务 Parallel.For()、Prarllel.ForEach()循环。还计算了运行时间方便观看执行效率。
C#并行编程-并发集合
weixin_30721077的博客
09-06 206
C#并行编程-并发集合 原文:C#并行编程-并发集合菜鸟学习并行编程，参考《C#并行编程高级教程.PDF》，如有错误，欢迎指正。 背景 基于任务的程序设计、命令式数据并行和任务并行都要求能够支持并发更新的数组、列表和集合。 在.NET Framework 4 以前，为了让共享的数组、列表和集合能够被多个线程更新，需要添加复杂的代码来同步这...
C#系列-并行处理+异步流（5）
最新发布
赵玉的专栏
02-09 906
在.NET Core和.NET 5+中，System.IO.Pipes和System.Threading.Channels命名空间提供了额外的工具来创建和使用管道和通道，这些工具特别适合在进程间或线程间传递异步数据流。Task.Run 方法用于在线程池线程上异步执行代码。使用async和await关键字来编写异步方法，这些方法可以返回Task或Task，并且可以在其中执行异步操作，如读取文件、访问网络等。中，并行处理指的是同时执行多个任务或操作，以利用多核或多处理器的优势，从而提高应用程序的性能。
C# 数据库并发的解决方案（通用版、EF版）
vic_0318的博客
03-26 358
C# 数据库并发的解决方案（通用版、EF版） https://www.cnblogs.com/chenwolong/p/7506299.html
c# 并行计算（大量循环处理的场景下）
Byronloong 的博客
05-18 425
并行指有多个CPU资源同时处理多个线程，不存在竞争的概念，可以大量节省运行时间。
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程：线程池的使用 - 平凡希 - 博客园平凡希博客园首页联系管理随笔 - 127 文章 - 1 评论 - 94Java并发编程：线程池的使用在前面
dotnet-博客园第三方Android客户端XamarinAppMaterialDesign风格
08-15
博客园第三方Android客户端，Xamarin App，Material Design风格
C#常用命名空间 - 天琊蓝 - 博客园.pdf
10-11
C#常用命名空间 ，C#常用命名空间 -，C#常用命名空间 -
RSA加密解密在jsencrypt+c#的实现-博客园加密登录-附件资源
03-02
RSA加密解密在jsencrypt+c#的实现-博客园加密登录-附件资源
C#编程总结（九）字符编码 - 停留的风 - 博客园.mhtml
12-25
C#编程总结（九）字符编码 - 停留的风 - 博客园.mhtml
C# 循环中实现并发（Task,Parallel）应用示例
一个编程的同学
09-01 934
【代码】C# 循环中实现并发（Task,Parallel）应用示例。
C#并发实战Parallel.ForEach使用
weixin_40362806的博客
06-15 4863
前言：最近给客户开发一个伙食费计算系统，大概需要计算2000个人的伙食。需求是按照员工的预定报餐计划对消费记录进行检查，如有未报餐有刷卡或者有报餐没刷卡的要进行一定的金额扣减等一系列规则。一开始我的想法比较简单，直接用一个for循环搞定，统计结果倒是没问题，但是计算出来太慢了需要7，8分钟。这样系统服务是报超时错误的，让人觉得有点不太爽。由于时间也不多就就先提交给用户使用了，后面逻辑又增加了，计算时间变长，整个计算一遍居然要将近10分钟了。这个对用户来说是能接收的（原来自己手算需要好几天呢），但是我自己接受
C#并行编程（3）：并行循环
dotNET跨平台
04-13 1720
初识并行循环并行循环主要用来处理数据并行的，如，同时对数组或列表中的多个数据执行相同的操作。在C#编程中，我们使用并行类System.Threading.Tasks.Pa...
C# Task 循环任务_C# 异步并发操作，只保留最后一次操作
weixin_39768917的博客
11-23 754
(给DotNet加星标，提升.Net技能)转自：唐宋元明清2188cnblogs.com/kybs0/p/11988554.html在我们业务操作时，难免会有多次操作，我们期望什么结果呢？绝大部分情况，应该是只需要最后一次操作的结果，其它操作应该无效。自定义等待的任务类1、可等待的任务类 AwaitableTask:/// 无效的操作可以分为以下俩种：已经进行中的操作，后续结果应标记为无...
C# 集合-并发处理-锁OR线程
weixin_33924220的博客
08-23 430
   每次写博客，第一句话都是这样的：程序员很苦逼，除了会写程序，还得会写博客！当然，希望将来的一天，某位老板看到此博客，给你的程序员职工加点薪资吧！因为程序员的世界除了苦逼就是沉默。我眼中的程序员大多都不爱说话，默默承受着编程的巨大压力，除了技术上的交流外，他们不愿意也不擅长和别人交流，更不乐意任何人走进他们的内心！    最近悟出来一个道理，在这儿分享给大家：学历代表你的过去，能力代表你的现...
【C#】并行编程实战：并行编程简介
cyf649669121的博客
06-13 2496
本章内容为多线程编程入门知识，旨在介绍多线程的特点，以及提供了C#部分基础的多线程API使用。
C#基础之并行编程
weixin_30482383的博客
02-14 357
　　并行编程从业务实现的角度可分为数据并行与任务并行，也就是要解决的问题是以数据为核心还是以要处理的事情为核心。基于任务的并行编程模型TPL(任务并行库)是从业务角度实现的并行模型，它以System.Threading.Tasks命名空间下的Parallel类为实现核心类，优点是不需要我们考虑不同的硬件差异，只需要重点关注所实现的任务。 1.任务并行库TPL 　　TPL主要包括数据并行和任务并...
【C#】并行编程实战：任务并行性（上）
cyf649669121的博客
06-14 3329
在 .NET 的初始版本中，我们只能依赖线程（线程可以直接创建或者使用 ThreadPool 类创建）。ThreadPool 类提供了一个托管抽象层，但是开发人员仍然需要依靠 Thread 类来进行更好的控制。而 Thread 类维护困难，且不可托管，给内存和 CPU 带来沉重负担。 因此，我们需要一种方案，既能充分利用 Thread 类的优点，又规避它的困难。这就是任务 （Task）。
java之bigdecimal详解 - 华仔coding - 博客园 (cnblogs.com)
09-19
BigDecimal是Java中的一个类，用于实现高精度的十进制计算。 在Java中，普通的浮点型数据类型（如float和double）存在精度问题。例如，使用float类型计算0.1+0.2的结果可能是0.30000000000000004而不是0.3。而BigDecimal类可以帮助我们解决这个问题。 BigDecimal类提供了精确的算术运算，可以进行加、减、乘和除等运算，并且可以设置精度和舍入模式。我们可以通过传递字符串参数来创建BigDecimal对象，也可以通过传递整数或浮点数参数来创建。 除了基本的算术运算，BigDecimal类还提供了比较、取反、取绝对值、取最大/小值等功能方法，以及其他一些常用的操作，如取余、取整等。 当处理带有小数点的金额、利率、税率等场景时，使用BigDecimal可以保证计算结果的准确性。 同时，BigDecimal还可以处理较大或较小的数值，可以设置任意精度的小数位数，并且不会丢失精度。 然而，由于BigDecimal类属于不可变类，每次进行运算时都会生成一个新的BigDecimal对象，因此在频繁进行运算的场景中，可能会占用大量的内存和CPU资源。 总之，BigDecimal类提供了一种精确计算的方案，可以解决浮点数精度不准确的问题，在处理财务数据等场景中非常有用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值