菜鸟学习并行编程，参考《C#并行编程高级教程.PDF》，如有错误，欢迎指正。

目录

背景

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

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

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

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

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

  1.     class Program
  2.     {
  3.         private static object o = new object();
  4.         private static List<Product> _Products { get; set; }
  5.         /*  coder:释迦苦僧
  6.          *  代码中 创建三个并发线程 来操作_Products 集合
  7.          *  System.Collections.Generic.List 这个列表在多个线程访问下，不能保证是安全的线程，所以不能接受并发的请求，我们必须对ADD方法的执行进行串行化
  8.          */
  9.         static void Main(string[] args)
  10.         {
  11.             _Products = new List<Product>();
  12.             /*创建任务 t1  t1 执行 数据集合添加操作*/
  13.             Task t1 = Task.Factory.StartNew(() =>
  14.             {
  15.                 AddProducts();
  16.             });
  17.             /*创建任务 t2  t2 执行 数据集合添加操作*/
  18.             Task t2 = Task.Factory.StartNew(() =>
  19.             {
  20.                 AddProducts();
  21.             });
  22.             /*创建任务 t3  t3 执行 数据集合添加操作*/
  23.             Task t3 = Task.Factory.StartNew(() =>
  24.             {
  25.                 AddProducts();
  26.             });
  27.             Task.WaitAll(t1, t2, t3);
  28.             Console.WriteLine(_Products.Count);
  29.             Console.ReadLine();
  30.         }
  31.  
  32.         /*执行集合数据添加操作*/
  33.         static void AddProducts()
  34.         {
  35.             Parallel.For(, , (i) =>
  36.             {
  37.                 Product product = new Product();
  38.                 product.Name = "name" + i;
  39.                 product.Category = "Category" + i;
  40.                 product.SellPrice = i;
  41.                 _Products.Add(product);
  42.             });
  43.  
  44.         }
  45.     }
  46.  
  47.     class Product
  48.     {
  49.         public string Name { get; set; }
  50.         public string Category { get; set; }
  51.         public int SellPrice { get; set; }
  52.     }

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

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

  1.     class Program
  2.     {
  3.         private static object o = new object();
  4.         private static List<Product> _Products { get; set; }
  5.         /*  coder:释迦苦僧
  6.          *  代码中 创建三个并发线程 来操作_Products 集合
  7.          *  System.Collections.Generic.List 这个列表在多个线程访问下，不能保证是安全的线程，所以不能接受并发的请求，我们必须对ADD方法的执行进行串行化
  8.          */
  9.         static void Main(string[] args)
  10.         {
  11.             _Products = new List<Product>();
  12.             /*创建任务 t1  t1 执行 数据集合添加操作*/
  13.             Task t1 = Task.Factory.StartNew(() =>
  14.             {
  15.                 AddProducts();
  16.             });
  17.             /*创建任务 t2  t2 执行 数据集合添加操作*/
  18.             Task t2 = Task.Factory.StartNew(() =>
  19.             {
  20.                 AddProducts();
  21.             });
  22.             /*创建任务 t3  t3 执行 数据集合添加操作*/
  23.             Task t3 = Task.Factory.StartNew(() =>
  24.             {
  25.                 AddProducts();
  26.             });
  27.             Task.WaitAll(t1, t2, t3);
  28.             Console.WriteLine("当前数据量为：" + _Products.Count);
  29.             Console.ReadLine();
  30.         }
  31.  
  32.         /*执行集合数据添加操作*/
  33.         static void AddProducts()
  34.         {
  35.             Parallel.For(, , (i) =>
  36.             {
  37.                 Product product = new Product();
  38.                 product.Name = "name" + i;
  39.                 product.Category = "Category" + i;
  40.                 product.SellPrice = i;
  41.                 lock (o)
  42.                 {
  43.                     _Products.Add(product);
  44.                 }
  45.             });
  46.  
  47.         }
  48.     }
  49.  
  50.     class Product
  51.     {
  52.         public string Name { get; set; }
  53.         public string Category { get; set; }
  54.         public int SellPrice { get; set; }
  55.     }

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

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 是完全无锁的，能够支持并发的添加元素，先进先出。下面贴代码，详解见注释：

  1.     class Program
  2.     {
  3.         private static object o = new object();
  4.         /*定义 Queue*/
  5.         private static Queue<Product> _Products { get; set; }
  6.         private static ConcurrentQueue<Product> _ConcurrenProducts { get; set; }
  7.         /*  coder:释迦苦僧
  8.          *  代码中 创建三个并发线程 来操作_Products 和 _ConcurrenProducts 集合，每次添加 10000 条数据 查看 一般队列Queue 和 多线程安全下的队列ConcurrentQueue 执行情况
  9.          */
  10.         static void Main(string[] args)
  11.         {
  12.             Thread.Sleep();
  13.             _Products = new Queue<Product>();
  14.             Stopwatch swTask = new Stopwatch();
  15.             swTask.Start();
  16.  
  17.             /*创建任务 t1  t1 执行 数据集合添加操作*/
  18.             Task t1 = Task.Factory.StartNew(() =>
  19.             {
  20.                 AddProducts();
  21.             });
  22.             /*创建任务 t2  t2 执行 数据集合添加操作*/
  23.             Task t2 = Task.Factory.StartNew(() =>
  24.             {
  25.                 AddProducts();
  26.             });
  27.             /*创建任务 t3  t3 执行 数据集合添加操作*/
  28.             Task t3 = Task.Factory.StartNew(() =>
  29.             {
  30.                 AddProducts();
  31.             });
  32.  
  33.             Task.WaitAll(t1, t2, t3);
  34.             swTask.Stop();
  35.             Console.WriteLine("List<Product> 当前数据量为：" + _Products.Count);
  36.             Console.WriteLine("List<Product> 执行时间为：" + swTask.ElapsedMilliseconds);
  37.  
  38.             Thread.Sleep();
  39.             _ConcurrenProducts = new ConcurrentQueue<Product>();
  40.             Stopwatch swTask1 = new Stopwatch();
  41.             swTask1.Start();
  42.  
  43.             /*创建任务 tk1  tk1 执行 数据集合添加操作*/
  44.             Task tk1 = Task.Factory.StartNew(() =>
  45.             {
  46.                 AddConcurrenProducts();
  47.             });
  48.             /*创建任务 tk2  tk2 执行 数据集合添加操作*/
  49.             Task tk2 = Task.Factory.StartNew(() =>
  50.             {
  51.                 AddConcurrenProducts();
  52.             });
  53.             /*创建任务 tk3  tk3 执行 数据集合添加操作*/
  54.             Task tk3 = Task.Factory.StartNew(() =>
  55.             {
  56.                 AddConcurrenProducts();
  57.             });
  58.  
  59.             Task.WaitAll(tk1, tk2, tk3);
  60.             swTask1.Stop();
  61.             Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  62.             Console.WriteLine("ConcurrentQueue<Product> 执行时间为：" + swTask1.ElapsedMilliseconds);
  63.             Console.ReadLine();
  64.         }
  65.  
  66.         /*执行集合数据添加操作*/
  67.         static void AddProducts()
  68.         {
  69.             Parallel.For(, , (i) =>
  70.             {
  71.                 Product product = new Product();
  72.                 product.Name = "name" + i;
  73.                 product.Category = "Category" + i;
  74.                 product.SellPrice = i;
  75.                 lock (o)
  76.                 {
  77.                     _Products.Enqueue(product);
  78.                 }
  79.             });
  80.  
  81.         }
  82.         /*执行集合数据添加操作*/
  83.         static void AddConcurrenProducts()
  84.         {
  85.             Parallel.For(, , (i) =>
  86.             {
  87.                 Product product = new Product();
  88.                 product.Name = "name" + i;
  89.                 product.Category = "Category" + i;
  90.                 product.SellPrice = i;
  91.                 _ConcurrenProducts.Enqueue(product);
  92.             });
  93.  
  94.         }
  95.     }
  96.  
  97.     class Product
  98.     {
  99.         public string Name { get; set; }
  100.         public string Category { get; set; }
  101.         public int SellPrice { get; set; }
  102.     }

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

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

  1.     class Program
  2.     {
  3.         private static object o = new object();
  4.         private static ConcurrentQueue<Product> _ConcurrenProducts { get; set; }
  5.         /*  coder:释迦苦僧
  6.          *  ConcurrentQueue  下的 TryPeek 和 TryDequeue
  7.          */
  8.         static void Main(string[] args)
  9.         {
  10.             _ConcurrenProducts = new ConcurrentQueue<Product>();
  11.             /*执行添加操作*/
  12.             Console.WriteLine("执行添加操作");
  13.             Parallel.Invoke(AddConcurrenProducts, AddConcurrenProducts);
  14.             Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  15.             /*执行TryPeek操作   尝试返回不移除*/
  16.             Console.WriteLine("执行TryPeek操作   尝试返回不移除");
  17.             Parallel.Invoke(PeekConcurrenProducts, PeekConcurrenProducts);
  18.             Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  19.  
  20.             /*执行TryDequeue操作  尝试返回并移除*/
  21.             Console.WriteLine("执行TryDequeue操作  尝试返回并移除");
  22.             Parallel.Invoke(DequeueConcurrenProducts, DequeueConcurrenProducts);
  23.             Console.WriteLine("ConcurrentQueue<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  24.  
  25.             Console.ReadLine();
  26.         }
  27.  
  28.         /*执行集合数据添加操作*/
  29.         static void AddConcurrenProducts()
  30.         {
  31.             Parallel.For(, , (i) =>
  32.             {
  33.                 Product product = new Product();
  34.                 product.Name = "name" + i;
  35.                 product.Category = "Category" + i;
  36.                 product.SellPrice = i;
  37.                 _ConcurrenProducts.Enqueue(product);
  38.             });
  39.         }
  40.         /*尝试返回 但不移除*/
  41.         static void PeekConcurrenProducts()
  42.         {
  43.             Parallel.For(, , (i) =>
  44.             {
  45.                 Product product = null;
  46.                 bool excute = _ConcurrenProducts.TryPeek(out product);
  47.                 Console.WriteLine(product.Name);
  48.             });
  49.         }
  50.         /*尝试返回 并 移除*/
  51.         static void DequeueConcurrenProducts()
  52.         {
  53.             Parallel.For(, , (i) =>
  54.             {
  55.                 Product product = null;
  56.                 bool excute = _ConcurrenProducts.TryDequeue(out product);
  57.                 Console.WriteLine(product.Name);
  58.             });
  59.         }
  60.     }
  61.  
  62.     class Product
  63.     {
  64.         public string Name { get; set; }
  65.         public string Category { get; set; }
  66.         public int SellPrice { get; set; }
  67.     }

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

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

  1.         private static object o = new object();
  2.         /*定义 Stack*/
  3.         private static Stack<Product> _Products { get; set; }
  4.         private static ConcurrentStack<Product> _ConcurrenProducts { get; set; }
  5.         /*  coder:释迦苦僧
  6.          *  代码中 创建三个并发线程 来操作_Products 和 _ConcurrenProducts 集合，每次添加 30000 条数据 查看 一般Stack 和 多线程安全下的 ConcurrentStack 执行情况
  7.          */
  8.         static void Main(string[] args)
  9.         {
  10.             Thread.Sleep();
  11.             _Products = new Stack<Product>();
  12.             Stopwatch swTask = new Stopwatch();
  13.             swTask.Start();
  14.  
  15.             /*创建任务 t1  t1 执行 数据集合添加操作*/
  16.             Task t1 = Task.Factory.StartNew(() =>
  17.             {
  18.                 AddProducts();
  19.             });
  20.             /*创建任务 t2  t2 执行 数据集合添加操作*/
  21.             Task t2 = Task.Factory.StartNew(() =>
  22.             {
  23.                 AddProducts();
  24.             });
  25.             /*创建任务 t3  t3 执行 数据集合添加操作*/
  26.             Task t3 = Task.Factory.StartNew(() =>
  27.             {
  28.                 AddProducts();
  29.             });
  30.  
  31.             Task.WaitAll(t1, t2, t3);
  32.             swTask.Stop();
  33.             Console.WriteLine("List<Product> 当前数据量为：" + _Products.Count);
  34.             Console.WriteLine("List<Product> 执行时间为：" + swTask.ElapsedMilliseconds);
  35.  
  36.             Thread.Sleep();
  37.             _ConcurrenProducts = new ConcurrentStack<Product>();
  38.             Stopwatch swTask1 = new Stopwatch();
  39.             swTask1.Start();
  40.  
  41.             /*创建任务 tk1  tk1 执行 数据集合添加操作*/
  42.             Task tk1 = Task.Factory.StartNew(() =>
  43.             {
  44.                 AddConcurrenProducts();
  45.             });
  46.             /*创建任务 tk2  tk2 执行 数据集合添加操作*/
  47.             Task tk2 = Task.Factory.StartNew(() =>
  48.             {
  49.                 AddConcurrenProducts();
  50.             });
  51.             /*创建任务 tk3  tk3 执行 数据集合添加操作*/
  52.             Task tk3 = Task.Factory.StartNew(() =>
  53.             {
  54.                 AddConcurrenProducts();
  55.             });
  56.  
  57.             Task.WaitAll(tk1, tk2, tk3);
  58.             swTask1.Stop();
  59.             Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  60.             Console.WriteLine("ConcurrentStack<Product> 执行时间为：" + swTask1.ElapsedMilliseconds);
  61.             Console.ReadLine();
  62.         }
  63.  
  64.         /*执行集合数据添加操作*/
  65.         static void AddProducts()
  66.         {
  67.             Parallel.For(, , (i) =>
  68.             {
  69.                 Product product = new Product();
  70.                 product.Name = "name" + i;
  71.                 product.Category = "Category" + i;
  72.                 product.SellPrice = i;
  73.                 lock (o)
  74.                 {
  75.                     _Products.Push(product);
  76.                 }
  77.             });
  78.  
  79.         }
  80.         /*执行集合数据添加操作*/
  81.         static void AddConcurrenProducts()
  82.         {
  83.             Parallel.For(, , (i) =>
  84.             {
  85.                 Product product = new Product();
  86.                 product.Name = "name" + i;
  87.                 product.Category = "Category" + i;
  88.                 product.SellPrice = i;
  89.                 _ConcurrenProducts.Push(product);
  90.             });
  91.  
  92.         }
  93.     }
  94.  
  95.     class Product
  96.     {
  97.         public string Name { get; set; }
  98.         public string Category { get; set; }
  99.         public int SellPrice { get; set; }
  100.     }

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

  1.     class Program
  2.     {
  3.         private static object o = new object();
  4.         private static ConcurrentStack<Product> _ConcurrenProducts { get; set; }
  5.         /*  coder:释迦苦僧
  6.          *  ConcurrentQueue  下的 TryPeek 和 TryPop
  7.          */
  8.         static void Main(string[] args)
  9.         {
  10.             _ConcurrenProducts = new ConcurrentStack<Product>();
  11.             /*执行添加操作*/
  12.             Console.WriteLine("执行添加操作");
  13.             Parallel.Invoke(AddConcurrenProducts, AddConcurrenProducts);
  14.             Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  15.             /*执行TryPeek操作   尝试返回不移除*/
  16.             Console.WriteLine("执行TryPeek操作   尝试返回不移除");
  17.             Parallel.Invoke(PeekConcurrenProducts, PeekConcurrenProducts);
  18.             Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  19.  
  20.             /*执行TryDequeue操作  尝试返回并移除*/
  21.             Console.WriteLine("执行TryPop操作  尝试返回并移除");
  22.             Parallel.Invoke(PopConcurrenProducts, PopConcurrenProducts);
  23.             Console.WriteLine("ConcurrentStack<Product> 当前数据量为：" + _ConcurrenProducts.Count);
  24.  
  25.             Console.ReadLine();
  26.         }
  27.  
  28.         /*执行集合数据添加操作*/
  29.         static void AddConcurrenProducts()
  30.         {
  31.             Parallel.For(, , (i) =>
  32.             {
  33.                 Product product = new Product();
  34.                 product.Name = "name" + i;
  35.                 product.Category = "Category" + i;
  36.                 product.SellPrice = i;
  37.                 _ConcurrenProducts.Push(product);
  38.             });
  39.         }
  40.         /*尝试返回 但不移除*/
  41.         static void PeekConcurrenProducts()
  42.         {
  43.             Parallel.For(, , (i) =>
  44.             {
  45.                 Product product = null;
  46.                 bool excute = _ConcurrenProducts.TryPeek(out product);
  47.                 Console.WriteLine(product.Name);
  48.             });
  49.         }
  50.         /*尝试返回 并 移除*/
  51.         static void PopConcurrenProducts()
  52.         {
  53.             Parallel.For(, , (i) =>
  54.             {
  55.                 Product product = null;
  56.                 bool excute = _ConcurrenProducts.TryPop(out product);
  57.                 Console.WriteLine(product.Name);
  58.             });
  59.         }
  60.     }
  61.  
  62.     class Product
  63.     {
  64.         public string Name { get; set; }
  65.         public string Category { get; set; }
  66.         public int SellPrice { get; set; }
  67.     }

对于并发下的其他集合，我这边就不做代码案列了，大家可以通过下面的链接查看,如有问题，欢迎指正

http://msdn.microsoft.com/zh-cn/library/system.collections.concurrent(v=vs.110).aspx

作者：释迦苦僧 出处：http://www.cnblogs.com/woxpp/p/3935557.html
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。

C#并行编程-并发集合的更多相关文章

  1. 转载 .Net多线程编程—并发集合 https://www.cnblogs.com/hdwgxz/p/6258014.html

    集合 1 为什么使用并发集合? 原因主要有以下几点: System.Collections和System.Collections.Generic名称空间中所提供的经典列表.集合和数组都不是线程安全的, ...

  2. .Net多线程编程—并发集合

    并发集合 1 为什么使用并发集合? 原因主要有以下几点: System.Collections和System.Collections.Generic名称空间中所提供的经典列表.集合和数组都不是线程安全 ...

  3. C#并行编程系列-文章导航

    菜鸟初步学习,不对的地方请大神指教,参考<C#并行编程高级教程.pdf> 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 C# ...

  4. C#并行编程-相关概念

    菜鸟初步学习,不对的地方请大神指教,参考<C#并行编程高级教程.pdf> 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 C# ...

  5. C#并行编程-Parallel

    菜鸟学习并行编程,参考<C#并行编程高级教程.PDF>,如有错误,欢迎指正. 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 ...

  6. C#并行编程-Task

    菜鸟学习并行编程,参考<C#并行编程高级教程.PDF>,如有错误,欢迎指正. 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 ...

  7. C#并行编程-线程同步原语

    菜鸟学习并行编程,参考<C#并行编程高级教程.PDF>,如有错误,欢迎指正. 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 ...

  8. C#并行编程-PLINQ:声明式数据并行

    目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 C#并行编程-线程同步原语 C#并行编程-PLINQ:声明式数据并行 背景 通过LINQ可 ...

  9. C#并行编程-PLINQ:声明式数据并行-转载

    C#并行编程-PLINQ:声明式数据并行   目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 C#并行编程-线程同步原语 C#并行编程-P ...

随机推荐

  1. 攻破JAVA NIO技术壁垒

    转载自攻破JAVA NIO技术壁垒 概述 NIO主要有三大核心部分:Channel(通道),Buffer(缓冲区), Selector.传统IO基于字节流和字符流进行操作,而NIO基于Channel和 ...

  2. MAT-Java内存分析工具

    对Mat工具的详细介绍,引用博文:http://my.oschina.net/biezhi/blog/286223 下载地址:http://www.eclipse.org/mat/downloads. ...

  3. WInform关闭程序的几种方法以及区别。

    1.this.Close(); 关闭窗体,如果关闭的是主窗体 程序结束.2.Application.Exit(); 退出所有的窗体但是如果有托管线程的话无法完全退出3.Application.Exit ...

  4. spring AOP应用

    转自:http://wb284551926.iteye.com/blog/1887650 最近新项目要启动,在搭建项目基础架构的时候,想要加入日志功能和执行性能监控的功能,想了很多的想法,最后还是想到 ...

  5. ubuntu安装erlang

    照着园子里一篇博文安装erlang,各种错调不出来.最后发现官网有解决方案: https://www.erlang-solutions.com/downloads/download-erlang-ot ...

  6. 正则表达式统计java代码空白行，有效代码

    import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import jav ...

  7. 《理解 ES6》阅读整理：函数（Functions）（七）Block-Level Functions

    块级函数(Block-Level Functions) 在ES3及以前,在块内声明一个函数会报语法错误,但是所有的浏览器都支持块级函数.不幸的是,每个浏览器在支持块级函数方面都有一些细微的不同的行为. ...

  8. PAT/简单模拟习题集（一）

    B1001.害死人不偿命的(3n+1)猜想 (15) Description: 卡拉兹(Callatz)猜想: 对任何一个自然数n,如果它是偶数,那么把它砍掉一半:如果它是奇数,那么把(3n+1)砍掉 ...

  9. PyCharm 3.0 发布，提供免费开源版本

    PyCharm 发布最新的 3.0 版本,该版本新特性详见: http://www.jetbrains.com/pycharm/whatsnew/index.html 该版本最主要的是提供了免费开源的 ...

  10. JavaFX結合 JDBC, Servlet, Swing, Google Map及動態產生比例圖 (3)：部署設定及應用 （转帖）

    說明:這一篇主要是說明如何將程式部署到Application Server,以及程式如何運作,產生的檔案置於何處,以及如何以瀏覽器呈現(Applet),或是當成桌面應用程式,或是 桌面Applet,這 ...