anmei1912
anmei1912

基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技...

基于.net的分布式系统限流组件

 

     在互联网应用中，流量洪峰是常有的事情。在应对流量洪峰时，通用的处理模式一般有排队、限流，这样可以非常直接有效的保护系统，防止系统被打爆。另外，通过限流技术手段，可以让整个系统的运行更加平稳。今天要与大家分享一下限流算法和C#版本的组件。

基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第1张图片

一、令牌桶算法：

    令牌桶算法的基本过程如下：

  1. 假如用户配置的平均发送速率为r，则每隔1/r秒速率将一个令牌被加入到桶中；
  2. 假设桶最多可以存发b个令牌。当桶中的令牌达到上限后，丢弃令牌。
  3. 当一个有请求到达时，首先去令牌桶获取令牌，能够取到，则处理这个请求
  4. 如果桶中没有令牌，那么请求排队或者丢弃

     工作过程包括3个阶段：产生令牌、消耗令牌和判断数据包是否通过。其中涉及到2个参数：令牌产生的速率和令牌桶的大小，这个过程的具体工作如下。

  1. 产生令牌：周期性的以固定速率向令牌桶中增加令牌，桶中的令牌不断增多。如果桶中令牌数已到达上限，则丢弃多余令牌。
  2. 消费 令牌：业务程序根据具体业务情况消耗桶中的令牌。消费一次，令牌桶令牌减少一个。
  3. 判断是否通过：判断是否已有令牌桶是否存在有效令牌，当桶中的令牌数量可以满足需求时，则继续业务处理，否则将挂起业务，等待令牌。

     下面是C#的一个实现方式

class TokenBucketLimitingService: ILimitingService
    {
        private LimitedQueue limitedQueue = null;
        private CancellationTokenSource cancelToken;
        private Task task = null;
        private int maxTPS;
        private int limitSize;
        private object lckObj = new object();
        public TokenBucketLimitingService(int maxTPS, int limitSize)
        {
            this.limitSize = limitSize;
            this.maxTPS = maxTPS;

           if (this.limitSize <= 0)
                this.limitSize = 100;
            if(this.maxTPS <=0)
                this.maxTPS = 1;

           limitedQueue = new LimitedQueue(limitSize);
            for (int i = 0; i < limitSize; i++)
            {
                limitedQueue.Enqueue(new object());
            }
            cancelToken = new CancellationTokenSource();
            task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
        }

       ///


        /// 定时消息令牌
        ///
        private void TokenProcess()
        {
            int sleep = 1000 / maxTPS;
            if (sleep == 0)
                sleep = 1;

           DateTime start = DateTime.Now;
            while (cancelToken.Token.IsCancellationRequested ==false)
            {
                try
                {
                    lock (lckObj)
                    {
                        limitedQueue.Enqueue(new object());
                    }
                }
                catch
                {
                }
                finally
                {
                    if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
                    {
                        int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
                        if (newSleep > 1)
                            Thread.Sleep(newSleep - 1); //做一下时间上的补偿
                    }
                    start = DateTime.Now;
                }
            }
        }

       public void Dispose()
        {
            cancelToken.Cancel();
        }

       ///


        /// 请求令牌
        ///
        /// true：获取成功，false：获取失败
        public bool Request()
        {
            if (limitedQueue.Count <= 0)
                return false;
            lock (lckObj)
            {
                if (limitedQueue.Count <= 0)
                    return false;

               object data = limitedQueue.Dequeue();
                if (data == null)
                    return false;
            }

           return true;
        }
    }

public interface ILimitingService:IDisposable
     {
         ///


         /// 申请流量处理
         ///
         /// true：获取成功，false：获取失败
         bool Request();
         
     }

public class LimitingFactory
     {
         ///


         /// 创建限流服务对象
         ///
         /// 限流模型
         /// 最大QPS
         /// 最大可用票据数
         public static ILimitingService Build(LimitingType limitingType = LimitingType.TokenBucket, int maxQPS = 100, int limitSize = 100)
         {
             switch (limitingType)
             {
                 case LimitingType.TokenBucket:
                 default:
                     return new TokenBucketLimitingService(maxQPS, limitSize);
                 case LimitingType.LeakageBucket:
                     return new LeakageBucketLimitingService(maxQPS, limitSize);
             }
         }
     }

 

   ///


     /// 限流模式
     ///
     public enum LimitingType
     {
         TokenBucket,//令牌桶模式
         LeakageBucket//漏桶模式
     }

 

public class LimitedQueue : Queue
     {
         private int limit = 0;
         public const string QueueFulled = "TTP-StreamLimiting-1001";

        public int Limit
         {
             get { return limit; }
             set { limit = value; }
         }

        public LimitedQueue()
             : this(0)
         { }

        public LimitedQueue(int limit)
             : base(limit)
         {
             this.Limit = limit;
         }

        public new bool Enqueue(T item)
         {
             if (limit > 0 && this.Count >= this.Limit)
             {
                 return false;
             }
             base.Enqueue(item);
             return true;
         }
     }

     调用方法：

var service = LimitingFactory.Build(LimitingType.TokenBucket, 500, 200);

while (true)
{
      var result = service.Request();
       //如果返回true，说明可以进行业务处理，否则需要继续等待
       if (result)
       {
             //业务处理......
       }
       else
             Thread.Sleep(1);
}

二、漏桶算法

      声明一个固定容量的桶，每接受到一个请求向桶中添加一个令牌，当令牌桶达到上线后请求丢弃或等待，具体算法如下：

  1. 创建一个固定容量的漏桶，请求到达时向漏桶添加一个令牌
  2. 如果请求添加令牌不成功，请求丢弃或等待
  3. 另一个线程以固定的速率消费桶里的令牌

     工作过程也包括3个阶段：产生令牌、消耗令牌和判断数据包是否通过。其中涉及到2个参数：令牌自动消费的速率和令牌桶的大小，个过程的具体工作如下。

  1. 产生令牌：业务程序根据具体业务情况申请令牌。申请一次，令牌桶令牌加一。如果桶中令牌数已到达上限，则挂起业务后等待令牌。
  2. 消费令牌：周期性的以固定速率消费令牌桶中令牌，桶中的令牌不断较少。
  3. 判断是否通过：判断是否已有令牌桶是否存在有效令牌，当桶中的令牌数量可以满足需求时，则继续业务处理，否则将挂起业务，等待令牌。

    C#的一个实现方式：

class LeakageBucketLimitingService: ILimitingService
     {
         private LimitedQueue limitedQueue = null;
         private CancellationTokenSource cancelToken;
         private Task task = null;
         private int maxTPS;
         private int limitSize;
         private object lckObj = new object();
         public LeakageBucketLimitingService(int maxTPS, int limitSize)
         {
             this.limitSize = limitSize;
             this.maxTPS = maxTPS;

            if (this.limitSize <= 0)
                 this.limitSize = 100;
             if (this.maxTPS <= 0)
                 this.maxTPS = 1;

            limitedQueue = new LimitedQueue(limitSize);
             cancelToken = new CancellationTokenSource();
             task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
         }

        private void TokenProcess()
         {
             int sleep = 1000 / maxTPS;
             if (sleep == 0)
                 sleep = 1;

            DateTime start = DateTime.Now;
             while (cancelToken.Token.IsCancellationRequested == false)
             {
                 try
                 {

                    if (limitedQueue.Count > 0)
                     {
                         lock (lckObj)
                         {
                             if (limitedQueue.Count > 0)
                                 limitedQueue.Dequeue();
                         }
                     }
                 }
                 catch
                 {
                 }
                 finally
                 {
                     if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
                     {
                         int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
                         if (newSleep > 1)
                             Thread.Sleep(newSleep - 1); //做一下时间上的补偿
                     }
                     start = DateTime.Now;
                 }
             }
         }

        public void Dispose()
         {
             cancelToken.Cancel();
         }

        public bool Request()
         {
             if (limitedQueue.Count >= limitSize)
                 return false;
             lock (lckObj)
             {
                 if (limitedQueue.Count >= limitSize)
                     return false;

                return limitedQueue.Enqueue(new object());
             }
         }
     }

    调用方法：

var service = LimitingFactory.Build(LimitingType.LeakageBucket, 500, 200);

while (true)
{
      var result = service.Request();
       //如果返回true，说明可以进行业务处理，否则需要继续等待
      if (result)
       {
             //业务处理......
       }
       else
            Thread.Sleep(1);
}

两类限流算法虽然非常相似，但是还是有些区别的，供大家参考！

  1. 漏桶算法能够强行限制数据的传输速率。在某些情况下，漏桶算法不能够有效地使用网络资源。因为漏桶的漏出速率是固定的。
  2. 令牌桶算法能够在限制数据的平均传输速率的同时还允许某种程度的突发传输.

    1. C# DataGridView绑定List对象时，利用BindingList来实现增删查改

       

           当DataGridView的DataSource是DataTable的时候，DataTable的数据改变时，DataGridView的数据会随之改变，无需重新绑定到DataGridView。  当DataGridView的DataSource是泛型List，当List的数据改变时，则需要先将DataGridView的DataSource设置为new List()，再将改变后的List赋给DataGridView的DataSource。绑定List时，注意：切莫将DataGridView的DataSource设置为Null，否则会破坏DataGridView的列结构。

           如果要对绑定在DataGridView中的List进行数据的添加删除，先要把List转换成BindingList，再进行绑定：DataGridView.DataSource=new BindingList(new List)。否则的话会产生许多意想不到的错误。 如：初始绑定空数据后再添加数据绑定后，却取不到DataGridView.CurrentCell属性。

        IList list= new List();

        DataGridView.DataSource=list;//DataGridView的行不能添加删除

        DataGridView.DataSource=new BindingList(list);//DataGridView的行可以添加删除（只有允许添加行、删除行）

      示例代码：

      public partial class ucServer : UserControl
           {
               private List serverList;
               private BindingList dataBindings;

              public ucServer(List serverList)
               {
                   InitializeComponent();
                   if (serverList == null)
                       serverList = new List();
                   this.serverList = serverList;
                   dataBindings = new BindingList(this.serverList);
               }

              private void ucChecker_Load(object sender, EventArgs e)
               {
                   this.dgParams.DataSource = dataBindings;
               }

              private void llDownloadUrl_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
               {
                   MessageBox.Show("请设置下载地址。");
               }

              private void llHelp_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
               {
                   MessageBox.Show("请设置帮助信息。");
               }

              public bool IsValid()
               {
                   return true;//CheckService.Check(this.component);
               }

              private void btnAdd_Click(object sender, EventArgs e)
               {
                   ServerInfo info = new ServerInfo() {  OSType="Windows", Ports="8000-9999"};

                  dataBindings.Add(info);
               }

              private void btnDel_Click(object sender, EventArgs e)
               {
                   //允许删除多行

                  DataGridViewSelectedRowCollection rows = this.dgParams.SelectedRows;

                  foreach (DataGridViewRow row in rows)
                   {
                       this.dataBindings.RemoveAt(row.Index);
                   }
               }

          }

    2. .net中ThreadPool与Task的认识总结

       

           线程池和Task是多线程编程中两个经常使用的技术，大家在熟悉不过了。他们有什么关联关系？Task又是怎么工作的呢？估计很多时候会犯糊涂。通过翻阅资料，终于弄明白了，与大家分享一下。

       

      工作线程与I/O线程
           在ThreadPool中有这样一个方法：

      public static bool SetMaxThreads(int workerThreads, int completionPortThreads);

          此方法中有两个参数：workerThreads和completionPortThreads。这两个参数引申出了两个概念：辅助线程（也叫工作线程）和异步 I/O 线程。这两个线程有什么区别么？通过查阅资料，我们可以了解到，工作线程其实就是我们编码主动向ThreadPool中创建的线程。而I/O线程是线程池中预先保留出来的部分线程，这部分线程的作用是为了分发从IOCP（I/O completion port） 中的回调。

          那么什么是IOCP回调呢？

          在CLR内部，系统维护了一个IOCP（I/O completion port），它提供了处理多个异步I/O请求的线程模型。我们可以把IOCP看做是一个消息队列。当一个进程创建了一个IOCP，即创建了一个队列。当异步I/O请 求完成时，设备驱动程序就会生成一个I/O完成包,将它按照FIFO方式排队列入该完成端口。之后，会由I/O线程提取完成I/O请求包，并调用之前的委托。注意：异步调用服务时，回调函数都是运行于CLR线程池的I/O线程当中。

          I/O线程是由CLR调用的，通常情况下，我们不会直接用到它 。但是线程池中区分它们的目的是为了避免线程都去处理I/O回调而被耗尽，从而引发死锁。在编程时，开发人员需要关注的是确保I/O线程返回到线程池，I/O回调代码应该做尽量小的工作，并尽快返回到线程池，否则I/O线程会很快消耗光。如果回调代码中的工作很多的话，应该考虑把工作拆分到一个工作者线程中去。否则，I/O线程被耗尽，大量工作线程空闲，可能导致死锁。

          再补充一下，当执行I/O操作的时候，无论是同步I/O操作还是异步I/O操作，都会调用的Windows的API方法，比如，当读取文件时，调用ReadFile函数。该方法会将你的当前线程从用户态转变成内核态，会生成一个I/O请求包，并初始化这个请求包。ReadFile会向内核传递，根据这个请求包，windows内核知道需要将这个I/O操作发送给哪个硬件设备。这些I/O操作会进入设备自己的处理队列中，该队列由这个设备的驱动程序维护。

          如果此时是同步I/O操作，那么在硬件设备操作I/O的时候，发出I/O请求的线程由于无事可做被windows变成睡眠状态，当硬件设备完成操作后，再唤醒这个线程。这种方式非常直接，但是性能不高，如果请求数很多，那么休眠的线程数也很多，浪费了大量资源。

          如果是异步I/O操作（.Net中，异步的I/O操作大部分为BeginXXX的形式 ），该方法在Windows把I/O请求包发送到设备的处理队列后就返回。同时，在调用异步I/O操作时，即调用BeginXXX方法的时候，需要传入一个委托，该委托方法会随着I/O请求包一路传递到设备的驱动程序。在设备处理完I/O请求包后，将该委托再放到CLR线程池队列。

          总结来说，IOCP（I/O completion port）中有2个队列，一个是先进先出的队列，存放的是IO完成包，即已经完成的IO操作需要执行回调方法。还有一个队列是线程队列，IOCP会预分配一些线程在这个队列中，这样会比即时创建线程处理I/O请求速度更快。这个队列是后进先出的，好处是下一个请求的到来可能还是用之前的线程来处理，就不需要进行线程上下文切换，提高了性能。

          这里有一个IOCP的解释，写的很好。http://gamebabyrocksun.blog.163.com/blog/static/57153463201036104134250/ 

      Task的运行原理分析

          Task与ThreadPool什么关系呢？简单来说，Task是基于ThreadPool实现的，当然被标记为LongRunning的Task（单独创建线程实现）除外。Task被创建后，通过TaskScheduler执行工作项的分配。TaskScheduler会把工作项存储到两类队列中： 全局队列与本地队列。全局队列被设计为FIFO的队列。本地队列存储在线程中，被设计为LIFO.

          当主程序创建了一个Task后，由于创建这个Task的线程不是线程池中的线程，则TaskScheduler 会把该Task放入全局队列中。

          如果这个Task是由线程池中的线程创建，并且未设置TaskCreationOptions.PreferFairness标记（默认情况下未设置），TaskScheduler 会把该Task放入到该线程的本地队列中。如果设置了TaskCreationOptions.PreferFairness标记，则放入全局队列。

          官方的解释是： 最高级任务（即不在其他任务的上下文中创建的任务）与任何其他工作项一样放在全局队列上。 但是，嵌套任务或子任务（在其他任务的上下文中创建）的处理方式大不相同。 子任务或嵌套任务放置在特定于执行父任务的线程的本地队列上。 父任务可能是最高级任务，也可能是其他任务的子任务。

          那么任务放入到两类队列中后，是如何被执行的呢？

          当线程池中的线程准备好执行更多工作时，首先查看本地队列。 如果工作项在此处等待，直接通过LIFO的模式获取执行。 如果没有，则向全局队列以FIFO的模式获取工作项。如果全局队列也没有工作项，则查看其他线程的本地队列是否有可执行工作项，如果存在可执行工作项，则以FIFO的模式出队执行。

       

       

       

      C# 排序技术研究与对比

       

      一、 排序场景

      • 一维数组排序
      • 多维数组排序
      • 集合排序，例如Dictionary ,List, 自定义类集合排序等
      • DataTable排序

      二、 排序实现和测试

      1. 一维数组排序

      1.1 一维数组排序特点

          元素之间是一维线性的关系，每个元素只有一个下标，在排序场景下，每个元素的数据类型是一致的。例如：

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第2张图片

      1.2 C# 一维数组排序实现

      A：调用Array.Sort方法实现数组排序，不限制元素数据类型，底层基于对IComparable的接口实现

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第3张图片

      B：使用Linq实现排序

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第4张图片

      1.2 测试结果对比
       

      1000条数据（GUID）

      10000数据（GUID）

      100000数据（GUID）

      Array.Sort

      2ms

      35ms

      420ms

      Linq

      4ms

      74ms

      738ms

      可以看出， Array.Sort排序优于Linq的性能（越底层的结构，排序的性能越好）。

      2. 多维数组排序

      2.1 多维数组排序特点

      数组可以具有多个维度，支持多行多列，各个维度的数据类型可以不同。

      在此文中，交错数组不在研究范围内，主要研究的是不同数据类型的矩阵数组，这样更加贴近我们在实际场景中的数据。例如：

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第5张图片

      2.2 C# 多维数组排序实现

      Step1：定义一个对象排序类ObjectComparer，实现IComparer接口，主要负责数组中某个列的排序，

      如果要排序的列是int类型，进行如下比较即可：其他类推。

      clip_image006

      ObjectComparer类结构：

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第6张图片

      Step2：定义维度顺序整形数组：tagObjArray,实例化ObjectComparer对象，将要排序的数组作为参数传递给ObjectComparer的构造函数。

      clip_image008

      Step3：调用Array.Sort方法排序，参数：维度顺序整形数组：tagObjArray和ObjectComparer对象。

      clip_image009

      3. 集合排序

      3.1.ArrayList 类

      使用大小可按需动态增加的数组。

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第7张图片

      3.2 List 类

      可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法,在决定使用 List 还是使用 ArrayList 类（两者具有类似的功能）时， List 类在大多数情况下执行得更好并且是类型安全的。例子中的Sort其实调用的是String.Sort方法。

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第8张图片

      3.3 List和ArrayList性能测试对比
       

      ArrayList

      List

      100000

      498 ms

      538ms
      3.4 Dictionary类/SortedDictionary类

      从数据结构上来说都属于Hashtable，对关键字（键值）进行散列操作，适合键值对的存取，排序可以使用LINQ实现，建议使用SortedDictionary替换。

      Dictionary和HashTable内部实现差不多，但前者无需装箱拆箱操作，效率略高一点

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第9张图片

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第10张图片

      3.5 HashTable类

      Hashtable 主要用于键值快速查找，却没有提供排序的方法，所以它的排序需要借住数组或其它集合来实现。

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第11张图片

      HashTable中的key/value均为object类型，由包含集合元素的存储桶组成。存储桶是 HashTable中各元素的虚拟子组，与大多数集合中进行的搜索和检索相比，存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联，该哈希代码是使用哈希函数生成的并基于该元素的键。HashTable的优点就在于其索引的方式，速度非常快。如果以任意类型键值访问其中元素会快于其他集合，特别是当数据量特别大的时候，效率差别尤其大。

      HashTable的应用场合有：对象缓存，树递归算法的替代，和各种需提升效率的场合。

      3.6 Stack类

      Stack，栈，表示对象的简单的后进先出非泛型集合。Push方法入栈，Pop方法出栈。

      3.7 Queue类

      队列，先进先出。enqueue方法入队列，dequeue方法出队列。

      3.8 自定义类集合

      Step1：定义自定义类：Person

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第12张图片

      Step2：构造实体类集合：List persons

      clip_image016

      Step3:排序方法实现：

      1、直接排序

      clip_image017

      2、Person实现IComparable接口，直接调用Sort方法排序

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第13张图片

      直接调用Sort方法排序

      clip_image019

      3、Linq实现排序

      clip_image020

      测试结果对比：

       

      1．直接排序

      2．实现IComparable接口

      3．Linq

      100000

      75ms

      99ms

      29ms

      4. DataTable排序

      4.1 DataTable特点

      （1）DataTable 对象是按条件区分大小写的。（如果有两个 DataTable对象分别为“mydatatable”和“Mydatatable”，则搜索表的字符串被认为是区分大小写的。如果只有“mydatatable”而不存在“Mydatatable”，则该搜索表的字符串不区分大小写）。

      （2）以编程方式创建 DataTable，须先通过将 DataColumn 对象添加到 DataColumnCollection（通过 Columns 属性访问）中来定义其架构。

      （3）向 DataTable 添加行，须使用 NewRow 方法返回新的 DataRow 对象。（DataTable 可存储的最大行数是 16,777,216）。

      （4）DataTable 也包含可用于确保数据完整性的 Constraint 对象的集合

      （5）DataTable 事件（RowChanged、RowChanging、RowDeleting 和 RowDeleted）可用于确定对表进行更改的时间

      4.2 DataTable排序实现

      Step1: 构造DataTable

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第14张图片

      Step2：DataView排序

      clip_image022

      Step2：DataTable.Select排序

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第15张图片

      4.3 测试结果对比
       

      1．DataView排序

      2．DataTable.Select排序

      100000

      526 ms

      368ms

      对比下自定义类存储100000条相同数据的排序结果：

      测试结果对比：

       

      1．直接排序

      2．实现IComparable接口

      3．Linq

      100000

      75ms

      99ms

      29ms

      三、 排序效率总结

      1、 在数组排序中，建议使用Array.Sort 方式，优于LINQ方式

      2、 在自定义类排序时，推荐使用LINQ方式

      3、 DataTable和自定义类存储同类型数据时，自定义类的排序整体优于DataTable方式。

      4、 DataTable排序时，推荐使用DataTable.Select排序方式。

      5、 Dictionary和HashTable内部实现差不多，但Dictionary无需装箱拆箱操作，效率略高一点。数据量较大时，建议采用HashTable。

      6、 ArrayList集合的排序性能优于List集合。

      7、 Stack和Queue集合用于栈和队列操作。

       

       

       

      基于.net的通用内存缓存模型组件

       

          谈到缓存，我们自然而然就会想到缓存的好处，比如：

      •     降低高并发数据读取的系统压力：静态数据访问、动态数据访问
      •     存储预处理数据，提升系统响应速度和TPS
      •     降低高并发数据写入的系统压力
      •     提升系统可用性，后台宕机后，系统还存在可用的机会

          缓存技术一直是优化程序性能的一个重要手段，在互联网技术体系中，也不例外。但是在分布式架构下，大家开始更多的使用分布式缓存，比如Redis、MemcacheD等等，对进程内的内存缓存使用的越来越少。其主要原因无外乎几点：

           一是，数据不能做到强一致性，程序内存数据缓存同步的周期相对分布缓存更慢一些。

           二是，需要对缓存的各种同步策略进行封装，并控制同步时机。进程内缓存的使用比分布式缓存的使用具有更高的技术门槛。没有分布缓存使用简单。   

          虽然分布式缓存具有非常多很好的特性，但是当完全抛弃了程序内存缓存后，分布式缓存将会被滥用，应用程序甚至过度的依赖分布式缓存。笔者认为，任何一种技术的滥用，都将可能导致系统架构在健壮性上存在缺陷。分布式缓存虽然很好用，性能也不错，但是与进程内存缓存比起来，性能还是差了好多个数量级。要想把系统的性能做到极致，仅仅依赖Redis等分布式缓存还不不够的，还需要充分利用进程内存缓存。

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第16张图片

          缓存技术，从出现到现在，总结来说，已有四个阶段的发展：本地缓存、分布式缓存、弹性缓存平台，弹性应用平台。本地缓存的特点是数据存储在应用代码所在内存空间，可提供快速的数据访问，纳秒级性能。缺点也很明显，数据无法分布式共享，无容错处理。分布式缓存的特点是数据在固定数目的集群节点间分布存储，缓存容量可扩展(静态扩展)，但是扩展过程中需大量配置，无容错机制。弹性缓存平台的特性是数据在集群节点间分布存储，基于冗余机制实现高可用性。其优点是可动态扩展，具有容错能力，但是复制备份会对系统性能造成一定影响。弹性应用平台的特点是弹性缓存与代码执行的组合体，将业务逻辑代码转移到数据所在节点执行，极大地降低数据传输开销，提升系统性能。纵观整个缓存技术的发展，经历了从分散到集中，又到集中并分散的一个过程。弹性应用平台作为最终的缓存解决方案，已经不仅仅停留在缓存技术本身，而是更多的考虑了如何更好的与业务代码无缝集成，并提供进程内存级别的性能。

           基于此，我们规划设计了一个通用的内存缓存组件。通过此组件，可以实现各种内存数据的缓存，以及缓存数据同步等，并提供了分布式缓存数据同步到进程内存的方案。此组件与传统的缓存组件有很大的不同，它是对进程内存缓存的使用和同步做了抽象和总结，直接提供了一套模型。上文也提到，使用进程内存缓存最大的挑战在与数据同步，那么，我们先看一下影响进程内存缓存同步的一些因素。通过下图，我们看到在同步策略、同步时机、同步模式上都有很多选择。进程内存缓存的使用，其实就是下面三个维度组合处理的一个结果。

      基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技..._第17张图片

          在实际的业务中，同步策略更多的会基于时间、数据版本或者时间来做，然后选择合适的同步时机和模式来执行数据同步。所以，在组件的封装上，我们支持了三种应用模型：

      • 对缓存数据标记有效期，过期自动清理
      • 缓存数据时，同时缓存数据版本，定时校验或实时校验数据版本，发现版本不一致时清理或重新同步缓存数据
      • 缓存数据并订阅数据变化通知，当收到变化通知后，更新缓存数据

      模型一：对缓存数据标记有效期，过期自动清理

           此模型主要适用于， 比如：字符串资源信息查询、App充电地图数据、App最新动态、高频率日志记录、配置中心数据的缓存等等。

      • 数据实时性要求很低，访问频率很高，变化频率较小的数据查询

      • 访问频率很高，查询参数基本一致的数据查询

      • 访问频率很高，允许丢失的辅助信息写入

          代码示例：

      //nuget：Teld.Core
      //引用：Teld.Core.Cache.ServiceEx.dll
       

       

      // 创建一个带过期时间的本地内存容器
      using(var  container = LocalCacheService.CreateExpirationContainer("TTP-Cache-CFG"))
      {
           //向容器中增加项目，3秒钟的有效期
           container.Add("Name", "张三", new TimeSpan(0, 0, 3));
           //想容器中增加项目，永久有效
           container.Add("Address", "鑫盛大厦1号楼12层北特来电");
      }

      模型二：缓存数据时，同时缓存数据版本，定时校验或实时校验数据版本，发现版本不一致时清理或重新同步缓存数据

           此模型主要适用于， 比如：帮助查询等。

      • 数据实时性要求不高，访问频率很高的数据查询
      • 访问频率很高，查询参数基本一致的数据查询

           代码示例1： 定时同步，每分钟执行一次版本同步

      static voidMain(string[] args)

      {

         //创建缓存数据同步代理

         CacheValidateEventHandler handler = newCacheValidateEventHandler(SyncUserData);
         //创建一个带版本校验的本地内存缓存容器，每隔60s，自动进行一次数据全量同步
         using(varcontainer = LocalCacheService.CreateVersionContainer("TTP-Cache-User", handler, SyncTime.Timing, SyncModel.All, 60))

         {

             container.SyncFailed += Container_SyncFailed;   //数据同步失败，事件通知

             container.SyncData();   //立即执行一次数据同步

       

             var user = container.Get("Name");                     //从缓存中获取数据

             Console.WriteLine(JsonConvert.SerializeObject(user));

         }         

         Console.ReadLine();

      }
       

      //数据同步，返回全量或者增量数据，并返回数据的最新版本

      static Dictionary SyncUserData(CacheValidateEventArgs e,out stringnewVersion)

      {

         //通过e.Version获取上次同步的数据数据

         Dictionary result = new Dictionary();

         Random r = new Random(DateTime.Now.Second);
         result.Add("Name", new Cache.UserInfo() { Name = "Name", Age =r.Next(1,20) , IsMale= true , LastModifyTime = DateTime.Now});

         newVersion = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");

       

         return result;

      }

          代码示例2： 调用缓存Get方法时，自动同步缓存    

      static void Main (string[] args)

      { //创建缓存数据同步代理

           CacheValidateEventHandler handler = new CacheValidateEventHandler(SyncUserData);

           //创建一个带版本校验的本地内存缓存容器

           varcontainer = LocalCacheService.CreateVersionContainer("TTP-Cache-User", handler, SyncTime.GetCheck, SyncModel.All);

           container.SyncFailed += Container_SyncFailed; //数据同步失败，事件通知

           var user = container.Get("Name"); //从缓存数据中获取数据

           Console.WriteLine(JsonConvert.SerializeObject(user));

           Console.ReadLine();

      }

      模型三：缓存数据并订阅数据变化通知，当收到变化通知后，更新缓存数据

          此模型主要适用于， 比如：电站状态缓存等。

      • 数据实时性要求比较高，访问频率很高的数据查询

          代码示例1： 带事件更新通知的缓存    

      public void GetString_Invoke()

      {

      //创建一个带MQ变化通知的本地内存缓存容器

      using (var container = LocalCacheService.CreateEventContainer("TTP-Cache-EventCacheUnitTest",

                       (CacheValidateEventArgs e, out string newVersion) =>

                       {

                           newVersion = Guid.NewGuid().ToString();

      return BuildStringData();

                       }, SyncModel.All, 1))

                  {

                   container.SyncData(); //为容器初始化数据

                   var data = container.Get("lastModifytime");  //获取数据项

                   Assert.IsNotNull(data);

                   var data1 = container.Get("lastModifytime");

                   Assert.AreEqual(data, data1);

                   //发送数据项的更新通知事件

                   LocalCacheService.SendDataChangedEvent(container.Name, "lastModifytime");

                   Thread.Sleep(5000);

                   var data2 = container.Get("lastModifytime");

                   Assert.AreNotEqual(data2, data);

                  }

      }

          代码示例2：数据删除的事件通知

      public void GetString_Delete()
              {
                  //创建一个带MQ变化通知的本地内存缓存容器
                  using (var container = LocalCacheService.CreateEventContainer("TTP-Cache-EventCacheUnitTest",
                       (CacheValidateEventArgs e, out string newVersion) =>
                       {
                           newVersion = Guid.NewGuid().ToString();
                           return BuildStringData();
                       }, SyncModel.All, 1))
                  {
                      container.SyncData();                                                   //为容器初始化数据
                      var data = container.Get("lastModifytime");           //获取数据项
                      Assert.IsNotNull(data);
                      var data1 = container.Get("lastModifytime");
                      Assert.AreEqual(data, data1);
                       LocalCacheService.SendDataChangedEvent(container.Name,"lastModifytime", EventType.Delete);   //发送数据项的删除通知事件
                      Thread.Sleep(5000);
                      var data2 = container.Get("lastModifytime");
                      Assert.IsNull(data2);
                  }
              }

          以上是此缓存组件应用的三种模型。三种模型，可通过 LocalCacheService 创建。其代码如下：

      　public class LocalCacheService

          {
              /// 
              /// 创建过期自动清理的本地内存缓存容器
              /// 
              /// 容器标识,三段式命名，全局唯一：TTP-Resource-DataCache
              /// 限制使用的内存大小（M）
              public static IExpirationCacheContainer CreateExpirationContainer(string key,long? limitSize =null)
              {
                  if (string.IsNullOrEmpty(key))
                  {
                      throw new ArgumentException("Key值不能为空！", nameof(key));
                  }
                  return new InMemoryExpirationContainer(key, limitSize);
              }
              /// 
              /// 创建基于版本比较的本地内存缓存容器
              /// 
              /// 
              /// 容器标识,三段式命名，全局唯一：TTP-Resource-DataCache
              /// 基于版本比较的数据处理器
              /// 同步时机
              /// 同步模式
              /// 同步时机为Timing时，同步时间间隔
              /// 
              public static IVersionCacheContainer CreateVersionContainer(string key,CacheValidateEventHandler handler, SyncTime syncTime =SyncTime.Invoke,SyncModel model = SyncModel.All,int syncTimeSec=180) where T : class
              {
                  if (string.IsNullOrEmpty(key))
                  {
                      throw new ArgumentException("Key值不能为空！", nameof(key));
                  }
                  if (handler == null)
                  {
                      throw new ArgumentNullException(nameof(handler));
                  }
                  if (syncTimeSec == 0)
                      syncTimeSec = 180;
                  return new InMemoryVersionCacheContainer(key, handler, syncTime, model,TimeSpan.FromSeconds(syncTimeSec));
              }
              /// 
              /// 创建基于事件通知的本地内存缓存容器
              /// 
              /// 
              /// 容器标识,三段式命名，全局唯一：TTP-Resource-DataCache
              /// 基于版本比较的数据处理器
              /// 同步模式
              /// 同步时机为Timing时，同步时间间隔
              /// 
              public static IVersionCacheContainer CreateEventContainer(stringkey,CacheValidateEventHandler handler, SyncModel model = SyncModel.All, intsyncTimeSec = 180) where T : class
              {
                  if (string.IsNullOrEmpty(key))
                  {
                      throw new ArgumentException("Key值不能为空！", nameof(key));
                  }
                  if (handler == null)
                  {
                      throw new ArgumentNullException(nameof(handler));
                  }
                  if (syncTimeSec == 0)
                      syncTimeSec = 180;
                  return new InMemoryEventCacheContainer(key,model,handler,TimeSpan.FromSeconds(syncTimeSec));
              } 
          }

      　　同步模式和同步时机的定义如下：

      ///

      /// 同步模式
      ///


      public enum SyncModel : int
      {
          All, //全量同步，清楚历史缓存信息，重新插入
          Increase, //增量同步，同步变化部分，不对历史缓存数据清理
          Clear //仅清理历史数据
      }

      ///


      /// 同步时机
      ///
      public enum SyncTime : int
      {
          Invoke, //调用方执行SyncData方法主动同步
          Timing, //定时同步
          GetCheck //Get方法是自动同步
      }

      　　以上是我们在进程内存组件的一些实践心得，更多技术细节，欢迎同学们来电沟通。微信号：vveiliang

       

       

       

      Scala学习笔记：重要语法特性

       

      1.变量声明


      Scala 有两种变量， val 和 var  val的值声明后不可变，var可变

      val msg: String = "Hello yet again, world!"

      或者类型推断

      val msg = "Hello, world!"

      2.函数定义


      如果函数仅由一个句子组成，你可以可选地不写大括号。

      def max2(x: Int, y: Int) = if (x > y) x else y

      3.for循环


      打印每一个命令行参数的方法是：

      args.foreach(arg => println(arg))    

      如果函数文本由带一个参数的一句话组成，

      args.foreach(println)

      Scala 里只有一个指令式 for的函数式近似。

      for (arg <- args)
         println(arg)

      <- 的左边是变量，右边是数组。

      再比如带类型的参数化数组

      val greetStrings = new Array[String](3) 
        greetStrings(0) = "Hello"
        greetStrings(1) = ", "
        greetStrings(2) = "world!\n"
        for (i <- 0 to 2)
          print(greetStrings(i))

          注意这里的数组定义，只要new的时候带类型Array[String]就行了，val后面自动推断类型。
      注意这里的数组索引用的是()而不是java里面的[]。
      因为scala里面根本没有传统意义上的操作符，取而代之的是他们都可以转换为方法。例如greetStrings(i)可以转换成 greetStrings.apply(i)，
      greetStrings(0) = "Hello"  将被转化为 greetStrings.update(0, "Hello")

      尽管实例化之后你无法改变 Array 的长度，它的元素值却是可变的。因此，Array 是可变的对象。

      4.List对象


      创建一个 List 很简单。 List里面元素不可变。

      val oneTwoThree = List(1, 2, 3)

      List有个叫“ :::”的方法实现叠加功能。

      val oneTwo = List(1, 2)
      val threeFour = List(3, 4)
      val oneTwoThreeFour = oneTwo ::: threeFour             

      //结果是List(1, 2, 3, 4)

      Cons 把一个新元素组合到已有 List的最前端，然后返回结果 List。 例如，若执行这个脚本：

      val twoThree = list(2, 3)
      val oneTwoThree = 1 :: twoThree
      println(oneTwoThree)
      //你会看到： List(1, 2, 3)


      一个简单的需记住的规则：如果一个方法被用作操作符标注，如 a* b，那么方法被左操作数调用，就像 a.*(b)——除非方法名以冒号结尾。这种情况下，方法被右操作数调用。因此， 1 :: twoThree 里， ::方法被 twoThree 调用，传入 1，像这样： twoThree.::(1)。
      类 List 没有提供 append 操作，因为随着列表变长 append 的耗时将呈线性增长，而使用::做前缀则仅花费常量时间。如果你想通过添加元素来构造列表，你的选择是把它们前缀进去，当你完成之后再调用 reverse；

      5.元组


      与列表一样，元组也是不可变的，但与列表不同，元组可以包含不同类型的元素。

      val pair = (99, "Luftballons", 55)
          println(pair._1)
          println(pair._2)
          println(pair._3)

      注意这里第一个元素是从_1开始而不像List那样从0开始。

      6.Set和Map


      var jetSet = Set("Boeing", "Airbus")
      jetSet += "Lear"              

      默认set或者HashSet可变。即jetSet = jetSet + "Lear"

      如果要用不可变的set或者HashSet，要import

      import scala.collection.immutable.HashSet
      val hashSet = HashSet("Tomatoes", "Chilies")
      println(hashSet + "Coriander")             

      //这里就不能再赋值给hashSet了

      7.访问级别

      Public 是 Scala 的缺省访问级别。C++中struct默认是public，class默认是private。java类中的变量默认是default类型，只允许在同一个包内访问，一般用的时候跟private差不多。所以java用的时候要想用public必须要指出。

      class ChecksumAccumulator {
      private var sum = 0
      ...

      }

      8.静态对象：object


      Scala 比 Java 更面向对象的一个方面是 Scala 没有静态成员。替代品是， Scala 有单例对象： singleton object。除了用 object 关键字替换了 class 关键字以外，单例对象的定义看上去就像是类定义。

      import scala.collection.mutable.Map
      object ChecksumAccumulator {
      private val cache = Map[String, Int]()
      def calculate(s: String): Int =
      if (cache.contains(s))
      cache(s)
      else {
      .....
      }

      可以如下方式调用 ChecksumAccumulator单例对象的calculate方法：

      ChecksumAccumulator.calculate("Every value is an object.")

      也不用在实例化了。
      类和单例对象间的一个差别是，单例对象不带参数，而类可以。因为你不能用new关键字实例化一个单例对象， 你没机会传递给它参数。

      9.伴生对象


      当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象： companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类： companion class。类和它的伴生对象可以互相访问其私有成员。
      不与伴生类共享名称的单例对象被称为孤立对象： standalone object。 由于很多种原因你会用到它

      10.Main函数


      要执行Scala程序，你一定要提供一个有main方法（仅带一个参数， Array[String]，且结果类型为 Unit的孤立单例对象名。比如下面这个例子；

      import ChecksumAccumulator.calculate  
      object Summer {
           def main(args: Array[String]) {     //对比java里面的public static void

          main(String[] args){} 
               for (arg <- args)
               println(arg + ": " + calculate(arg))
           }
      }

      11.另一种Main函数


      Application 特质：在单例对象名后面写上“ extends Application” 。然后取代main 方法.

      import ChecksumAccumulator.calculate
      object FallWinterSpringSummer extends Application {
         for (season <- List("fall", "winter", "spring"))
         println(season +": "+ calculate(season))
      }

      效果和main函数一样。不过它也有些缺点。首先， 如果想访问命令行参数的话就不能用它，因为args数组不可访问。第二，如果你的程序是多线程的就需要显式的 main 方法。最后，某些JVM的实现没有优化被 Application 特质执行的对象的初始化代码。因此只有当你的程序相对简单和单线程情况下你才可以继承 Application 特质。

      12.带参数类声明

      Java 类具有可以带参数的构造器，而 Scala 类可以直接带参数。 Scala 的写法更简洁——类参数可以直接在类的主体中使用；没必要定义字段然后写赋值函数把构造器的参数复制到字段里。(不需要构造函数)
      例如以下分数构造器：

      class Rational(n: Int, d: Int) {
         require(d != 0)  
         override def toString = n +"/"+ d

        val numer: Int = n
         val denom: Int = d
         
         def add(that: Rational): Rational =       
         new Rational(
         numer * that.denom + that.numer * denom,
         denom * that.denom
      }

      require方法带一个布尔型参数。如果传入的值为真，require将正常返回。反之，require将通过抛出IllegalArgumentException来阻止对象被构造。 这里使用了重载。重载了类自带的toString函数。 这里that也就是随便起了个名字的变量，不是关键字。this是关键字。比如下面这个函数：

      def lessThan(that: Rational) =
      this.numer * that.denom < that.numer * this.denom

      这里的this可以省略。但下面这个就不能省略了：

      def max(that: Rational) =
        if (this.lessThan(that)) that else this

      13.if返回值


      Scala 的 if 可以产生值（是能返回值的表达式）。于是 Scala 持续了这种趋势让 for， try 和 match 也产生值。while不产生值，所以用得少。如果实在想用while，在纯函数式编程的时候可以考虑递归。
      指令式风格：

      var filename = "default.txt"
      if (!args.isEmpty)
      filename = args(0)

      函数式风格：

      val filename =
      if (!args.isEmpty) args(0)
      else "default.txt"

      使用 val 而不是 var 的第二点好处是他能更好地支持等效推论。无论何时都可以用表达式替代变量名。
      如要替代 println(filename)，你可以这么写：

      println(if (!args.isEmpty) args(0) else "default.txt")

      14.break 和 continue


      scala里面也没有break以及continue。如果想要用到他们的功能，可以使用增加布尔变量控制到循环语句判断中，类似：

      var foundIt = false  while (i < args.length && !foundIt) { }

      15.for过滤器


      在for里面还支持过滤器：

      val filesHere = (new java.io.File(".")).listFiles    //路径名的目录中的文件的数组。
      for (file <- filesHere if file.getName.endsWith(".scala"))
      println(file)

      甚至多个过滤器：

      for (
        file <- filesHere
        if file.isFile;
        if file.getName.endsWith(".scala")
      ) println(file)

       

      16.for循环生成新集合


      for {子句} yield {循环体} 制造新集合
      例如:

      def scalaFiles =
      for {
      file <- filesHere
      if file.getName.endsWith(".scala")
      } yield file

      这样每一步就不是打印一个file，而是将file存储起来，最终产生一个Array[File]

      17.try catch  finally

      try {
           val f = new FileReader("input.txt")
           openFile(file)

      } catch {
         case ex: FileNotFoundException =>  new FileReader("input.txt") 
         //注意这里依然有返回值。使用=>符号
         case ex: IOException => // Handle other I/O error
      }
      finally {
         file.close() // 确保关闭文件。
      }

      这里catch {
         case ex: 。。。
         case ex: 。。。
      }

      对比java，catch是这样用的  
      catch (Exception e) { 。。。。} 而且经常在catch里面throw。scala一般不使用throw。

      还有，finally里最好只做一些关闭或打印之类的操作，不要有副作用的表达式，这样会有无谓的返值。

      18.switch语句


      match语句就像java里的switch语句。

      val firstArg = if (args.length > 0) args(0) else ""
      firstArg match {
      case "salt" => println("pepper")
      case "chips" => println("salsa")
      case "eggs" => println("bacon")
      case _ => println("huh?")
      }

      差别：
      1、Java 的 case 语句里面的整数类型和枚举常量。而这里可以是任意类型，甚至正则匹配
      2、在每个可选项的最后并没有 break。取而代之， break是隐含的。
      3、match 表达式也能产生值：例如可以这样：

      val friend =
      firstArg match {
        case "salt" => "pepper"
        case "chips" => "salsa"
        case _ => "huh?"
      }
      println(friend)

      19.函数嵌套定义


      函数：函数式编程风格的一个重要设计原则：程序应该被解构成若干小的函数， 每个完成一个定义良好的任务。在java中通常这样做：

      def processFile(filename: String, width: Int) {
         ...
        for (line <- source.getLines)
         processLine(filename, width, line)
      }
      private def processLine(filename:String, width:Int, line:String) {
        ....
      }

      Scala 提供了另一种方式：你可以把函数定义在另一个函数中。就好象本地变量那样，这种本地函数仅在包含它的代码块中可见。

      def processFile(filename: String, width: Int) {
      def processLine(filename:String, width:Int, line:String) {
        ...
      }
      val source = Source.fromFile(filename)
      for (line <- source.getLines) {
      processLine(filename, width, line)
      }
      }

      20.Lambda函数


      Scala 拥有第一类函数： first-class function。你不仅可以定义函数和调用它们，还可以把函数写
      成没有名字的文本： (跟python里面的lambda函数差不多)

      scala> var increase = (x: Int) => x + 1
      scala> increase(10)
      res0: Int = 11

      如果你想在函数文本中包括超过一个语句，用大括号包住函数体，当函数值被调用时，所有的语句将被执行，而函数的返回值就是最后一行产生的那个表达式。

      scala> increase = (x: Int) => {
        println("We")
        println("are")
        println("here!")
        x + 1
      }

      21.集合通配符：_


      Scala 提供了许多方法去除冗余信息并把函数文本写得更简短。比如去除参数类型以及被推断的参数之外的括号：

      scala> someNumbers.filter(x => x > 0)

      如果想让函数文本更简洁，可以把下划线当做一个或更多参数的占位符，只要每个参数在函数文
      本内仅出现一次。 ：

      scala> someNumbers.filter(_ > 0)

      还可以使用一个下划线替换整个参数列表。叫偏应用函数

      scala> def sum(a: Int, b: Int, c: Int) = a + b + c

      一般调用可以这样：

      scala> sum(1, 2, 3)

      用偏函数取而代之：

      scala> val a = sum _  //请记住要在函数名和下划线之间留一个空格
      scala> a(1, 2, 3)

      再比如

      someNumbers.foreach(println _)

      22.闭包


      闭包：是指可以包含自由（未绑定到特定对象）变量的代码块
      任何带有自由变量的函数文本，如(x: Int) => x + more，都是开放术语：由于函数值是关闭这个开放术语(x: Int) => x + more 的行动的最终产物， 得到的函数值将包含一个指向捕获的 more 变量的参考， 因此被称为闭包。

      scala> var more = 1
      scala> val addMore = (x: Int) => x + more
      scala> addMore(10)
      res19: Int = 11

      每次函数被调用时都会创建一个新闭包。每个闭包都会访问闭包创建时活跃的 more 变量。

      23.重复参数


      想要标注一个重复参数，在参数的类型之后放一个星号。例如：

      scala> def echo(args: String*) =
              for (arg <- args) println(arg)

      这样定义， echo 可以被零个至多个 String 参数调用：

      scala> echo()
      scala> echo("one")
      scala> echo("hello", "world!")

      但是如果有一个数组变量
      scala> val arr = Array("What's", "up", "doc?")，则不能像scala> echo(arr)这样调用。
      你需要在数组参数后添加一个冒号和一个_*符号，像这样：

      scala> echo(arr: _*)

      24.curry化


      Scala 允许你创建新的“感觉像是原生语言支持”的控制抽象：scala提供curry 化：
      Scala里的Curry化可以把函数从接收多个参数转换成多个参数列表。如果要用同样的一组实参多次调用一个函数，可以用curry化来减少噪音，让代码更有味道。我们要编写的方法不是接收一个参数列表，里面有多个参数，而是有多个参数列表，每个里面可以有一个或多个参数。也就是说，写的不是def foo(a: Int, b: Int, c: Int){}，而是 def foo(a: Int)(b: Int)(c: Int){}。可以这样调用这个方法，比如：foo(1)(2)(3)、foo(1){2}{3}，甚至这样foo{1}{2}{3}。

      例如，传统函数如下：

      scala> def plainOldSum(x: Int, y: Int) = x + y

      scala> plainOldSum(1, 2)     //res5: Int = 3

      scala允许你使用curry化的新型函数：

      scala> def curriedSum(x: Int)(y: Int) = x + y
      scala> curriedSum(1)(2)             //res5: Int = 3

      结果一样。

      25.带函数参数的函数


      高阶函数： higher-order function——带其它函数做参数的函数

      def filesMatching(query: String,
        matcher: (String, String) => Boolean) = {
        for (file <- filesHere; if matcher(file.getName, query))
          yield file
      }

      这里matcher其实是一个函数，这里做了filesMatching函数的参数。
      (String, String) => Boolean)表示matcher函数的参数是(String, String)类型，而返回值是Boolean 类型
      你可以通过让多个搜索方法调用它，并传入合适的函数：

      def filesEnding(query: String) =
        filesMatching(query, _.endsWith(_))

      这就相当于

      def filesEnding(query: String) =
        for (file <- filesHere; if file.getName.endsWith(query))
         yield file

      因为上面matcher: (String, String)里面两个参数， matcher(file.getName, query)
      所以 _.endsWith(_)里面的第一个_对应于字符串file.getName，第二个_对应于字符串query，
      连在一起就是file.getName.endsWith(query)

      类似的

      def filesContaining(query: String) =
        filesMatching(query, _.contains(_))

      就相当于

      def filesContaining(query: String) =
         for (file <- filesHere; if file.getName.contains(query))
          yield file

       

      26.传名参数


      Scala中允许无参数的函数作为另一函数的参数传递进去,也就是传名参数(call-by-name)
      定义一个函数 myAssert ，而其参数则为传名参数。在这里，我们想要实现的是断言，可以将传名参数写成函数文本的格式：(…) => Type ，即参数列表 => 类型。

      def myAssert(check: () => Boolean) =
             if(!check()){
                    println("OK ...")
                    throw new AssertionError
             }

      上面的函数定义了一个当客户代码传入的函数值（这里我们用（）指明，代表省略了该函数的参数列表。调用方式如下：

      scala> myAssert(() => 5 < 3)

      客户端代码中的 () => 5 < 3 似乎有点繁琐，如果能够直接传入 5 < 3 之类的布尔表达式就更好了。这是可以实现的。只需要将函数定义 def 中空参数列表即小括号对（）去掉，直接用 => 而不是（）=> 就可以了。此外，if 判断中的 check 后面的（）也要同时去掉。修改后的代码如下：

      def myAssert(check: => Boolean) =
             if(!check){
                    println("OK ...")
                    throw new AssertionError
             } 
      myAssert(5 < 3)

转载于:https://www.cnblogs.com/cjm123/p/9053977.html

你可能感兴趣的:(基于.net的分布式系统限流组件 C# DataGridView绑定List对象时，利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技...)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • linux系统服务器下jsp传参数乱码 3213213333332132 javajsplinuxwindowsxml
    在一次解决乱码问题中， 发现jsp在windows下用js原生的方法进行编码没有问题，但是到了linux下就有问题， escape,encodeURI,encodeURIComponent等都解决不了问题 但是我想了下既然原生的方法不行，我用el标签的方式对中文参数进行加密解密总该可以吧。于是用了java的java.net.URLDecoder,结果还是乱码，最后在绝望之际，用了下面的方法解决了
  • Spring 注解区别以及应用 BlueSkator spring
    1. @Autowired @Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean，或者不存在UserDao类型的bean，会抛出 BeanCreationException异常，这时可以通过在该属性上再加一个@Qualifier注解来声明唯一的id解决问题。   2. @Qualifier 当spring中存在至少一个匹
  • printf和sprintf的应用 dcj3sjt126com PHPsprintfprintf
    <?php printf('b: %b <br>c: %c <br>d: %d <bf>f: %f', 80,80, 80, 80); echo '<br />'; printf('%0.2f <br>%+d <br>%0.2f <br>', 8, 8, 1235.456); printf('th
  • config.getInitParameter 171815164 parameter
    web.xml <servlet> <servlet-name>servlet1</servlet-name> <jsp-file>/index.jsp</jsp-file> <init-param> <param-name>str</param-name>
  • Ant标签详解--基础操作 g21121 ant
            Ant的一些核心概念：         build.xml：构建文件是以XML 文件来描述的，默认构建文件名为build.xml。        project：每个构建文
  • [简单]代码片段_数据合并 53873039oycg 代码
            合并规则:删除家长phone为空的记录,若一个家长对应多个孩子,保留一条家长记录,家长id修改为phone,对应关系也要修改。         代码如下:        
  • java 通信技术 云端月影 Java 远程通信技术
    在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来
  • string与StringBuilder 性能差距到底有多大 aijuans
              之前也看过一些对string与StringBuilder的性能分析，总感觉这个应该对整体性能不会产生多大的影响，所以就一直没有关注这块！         由于学程序初期最先接触的string拼接，所以就一直没改变过自己的习惯！        
  • 今天碰到 java.util.ConcurrentModificationException 异常 antonyup_2006 java多线程工作IBM
    今天改bug，其中有个实现是要对map进行循环，然后有删除操作，代码如下： Iterator<ListItem> iter = ItemMap.keySet.iterator(); while(iter.hasNext()){ ListItem it = iter.next(); //...一些逻辑操作 ItemMap.remove(it); } 结果运行报Con
  • PL/SQL的类型和JDBC操作数据库 百合不是茶 PL/SQL表标量类型游标PL/SQL记录
    PL/SQL的标量类型:    字符,数字,时间,布尔,%type五中类型的 --标量：数据库中预定义类型的变量 --定义一个变长字符串 v_ename varchar2(10); --定义一个小数,范围 -9999.99~9999.99 v_sal number(6,2); --定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号
  • Mockito：一个强大的用于 Java 开发的模拟测试框架实例 bijian1013 mockito单元测试
    Mockito框架：         Mockito是一个基于MIT协议的开源java测试框架。         Mockito区别于其他模拟框架的地方主要是允许开发者在没有建立“预期”时验证被测系统的行为。对于mock对象的一个评价是测试系统的测
  • 精通Oracle10编程SQL(10)处理例外 bijian1013 oracle数据库plsql
    /* *处理例外 */ --例外简介 --处理例外-传递例外 declare v_ename emp.ename%TYPE; begin SELECT ename INTO v_ename FROM emp where empno=&no; dbms_output.put_line('雇员名：'||v_ename); exceptio
  • 【Java】Java执行远程机器上Linux命令 bit1129 linux命令
    Java使用ethz通过ssh2执行远程机器Linux上命令，   封装定义Linux机器的环境信息   package com.tom; import java.io.File; public class Env { private String hostaddr; //Linux机器的IP地址 private Integer po
  • java通信之Socket通信基础 白糖_ javasocket网络协议
    正处于网络环境下的两个程序，它们之间通过一个交互的连接来实现数据通信。每一个连接的通信端叫做一个Socket。一个完整的Socket通信程序应该包含以下几个步骤： ①创建Socket； ②打开连接到Socket的输入输出流； ④按照一定的协议对Socket进行读写操作； ④关闭Socket。   Socket通信分两部分：服务器端和客户端。服务器端必须优先启动，然后等待soc
  • angular.bind boyitech AngularJSangular.bindAngularJS APIbind
    angular.bind 描述：         上下文，函数以及参数动态绑定，返回值为绑定之后的函数. 其中args是可选的动态参数，self在fn中使用this调用。 使用方法：          angular.bind(se
  • java-13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class KickOutBadGuys { /** * 题目：13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 * Maybe you can find out
  • Redis.conf配置文件及相关项说明（自查备用） Kai_Ge redis
       Redis.conf配置文件及相关项说明 # Redis configuration file example # Note on units: when memory size is needed, it is possible to specifiy # it in the usual form of 1k 5GB 4M and so forth: #
  • [强人工智能]实现大规模拓扑分析是实现强人工智能的前奏 comsci 人工智能
         真不好意思,各位朋友...博客再次更新...      节点数量太少,网络的分析和处理能力肯定不足,在面对机器人控制的需求方面,显得力不从心....      但是,节点数太多,对拓扑数据处理的要求又很高,设计目标也很高,实现起来难度颇大...
  • 记录一些常用的函数 dai_lm java
    public static String convertInputStreamToString(InputStream is) { StringBuilder result = new StringBuilder(); if (is != null) try { InputStreamReader inputReader = new InputStreamRead
  • Hadoop中小规模集群的并行计算缺陷 datamachine mapreducehadoop并行计算
    注：写这篇文章的初衷是因为Hadoop炒得有点太热，很多用户现有数据规模并不适用于Hadoop，但迫于扩容压力和去IOE（Hadoop的廉价扩展的确非常有吸引力）而尝试。尝试永远是件正确的事儿，但有时候不用太突进，可以调优或调需求，发挥现有系统的最大效用为上策。 -----------------------------------------------------------------
  • 小学4年级英语单词背诵第二课 dcj3sjt126com englishword
    egg  蛋 twenty 二十 any 任何 well 健康的，好   twelve 十二 farm 农场 every 每一个 back 向后，回   fast 快速的 whose 谁的 much 许多 flower 花   watch 手表 very 非常，很 sport 运动 Chinese 中国的  
  • 自己实践了github的webhooks, linux上面的权限需要注意 dcj3sjt126com githubwebhook
    环境, 阿里云服务器   1. 本地创建项目, push到github服务器上面   2. 生成www用户的密钥 sudo -u www ssh-keygen -t rsa -C "[email protected]"     3. 将密钥添加到github帐号的SSH_KEYS里面   3. 用www用户执行克隆, 源使
  • Java冒泡排序 蕃薯耀 冒泡排序Java冒泡排序Java排序
    冒泡排序 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 10:40:14 星期二 http://fanshuyao.iteye.com/
  • Excle读取数据转换为实体List【基于apache-poi】 hanqunfeng apache
    1.依赖apache-poi   2.支持xls和xlsx   3.支持按属性名称绑定数据值   4.支持从指定行、列开始读取   5.支持同时读取多个sheet   6.具体使用方式参见org.cpframework.utils.excelreader.CP_ExcelReaderUtilTest.java 比如： Str
  • 3个处于草稿阶段的Javascript API介绍 jackyrong JavaScript
    原文： http://www.sitepoint.com/3-new-javascript-apis-may-want-follow/?utm_source=html5weekly&utm_medium=email   本文中，介绍3个仍然处于草稿阶段，但应该值得关注的Javascript API. 1) Web Alarm API   &
  • 6个创建Web应用程序的高效PHP框架 lampcy Web框架PHP
    以下是创建Web应用程序的PHP框架，有coder bay网站整理推荐： 1. CakePHP CakePHP是一个PHP快速开发框架，它提供了一个用于开发、维护和部署应用程序的可扩展体系。CakePHP使用了众所周知的设计模式，如MVC和ORM，降低了开发成本，并减少了开发人员写代码的工作量。 2. CodeIgniter CodeIgniter是一个非常小且功能强大的PHP框架，适合需
  • 评"救市后中国股市新乱象泛起"谣言 nannan408
    首先来看百度百家一位易姓作者的新闻： 三个多星期来股市持续暴跌，跌得投资者及上市公司都处于极度的恐慌和焦虑中，都要寻找自保及规避风险的方式。面对股市之危机，政府突然进入市场救市，希望以此来重建市场信心，以此来扭转股市持续暴跌的预期。而政府进入市场后，由于市场运作方式发生了巨大变化，投资者及上市公司为了自保及为了应对这种变化，中国股市新的乱象也自然产生。 首先，中国股市这两天
  • 页面全屏遮罩的实现 方式 Rainbow702 htmlcss遮罩mask
    之前做了一个页面，在点击了某个按钮之后，要求页面出现一个全屏遮罩，一开始使用了position:absolute来实现的。当时因为画面大小是固定的，不可以resize的，所以，没有发现问题。 最近用了同样的做法做了一个遮罩，但是画面是可以进行resize的，所以就发现了一个问题，当画面被reisze到浏览器出现了滚动条的时候，就发现，用absolute 的做法是有问题的。后来改成fixed定位就
  • 关于angularjs的点滴 tntxia AngularJS
      angular是一个新兴的JS框架，和以往的框架不同的事，Angularjs更注重于js的建模，管理，同时也提供大量的组件帮助用户组建商业化程序，是一种值得研究的JS框架。   Angularjs使我们可以使用MVC的模式来写JS。Angularjs现在由谷歌来维护。   这里我们来简单的探讨一下它的应用。   首先使用Angularjs我
  • Nutz--->>反复新建ioc容器的后果 xiaoxiao1992428 DAOmvcIOCnutz
    问题： public class DaoZ {     public static Dao dao() { // 每当需要使用dao的时候就取一次     Ioc ioc = new NutIoc(new JsonLoader("dao.js"));     return ioc.get(