dotnet/Library/Sers/Sers.Core/Sers.Core/CL/MessageOrganize/DefaultOrganize/RequestAdaptor.cs

@@ -137,18 +137,18 @@ namespace Sers.Core.CL.MessageOrganize.DefaultOrganize
             heartBeatRetryCount = config["heartBeatRetryCount"]?.Deserialize<int?>() ?? heartBeatRetryCount;
             heartBeatIntervalMs = config["heartBeatIntervalMs"]?.Deserialize<int?>() ?? heartBeatIntervalMs;
 
-            requestTimeoutMs = config["workThread"]?["timeoutMs"]?.Deserialize<int?>() ?? 300000;
+            requestTimeoutMs = config["requestTimeoutMs"]?.Deserialize<int?>() ?? requestTimeoutMs;
 
 
             task_DeliveryToOrganize_Processor = ConsumerFactory.CreateConsumer<DeliveryToOrganize_MessageFrame>(config["workThread"] as JObject);
             task_DeliveryToOrganize_Processor.processor = DeliveryToOrganize_ProcessFrame;
-            task_DeliveryToOrganize_Processor.name = "CL-RequestAdaptor-dealer";
+            task_DeliveryToOrganize_Processor.threadName = "CL-RequestAdaptor-dealer";
         }
         #endregion
 
 
         #endregion
-               
+
 
 
 

dotnet/Library/Sers/Sers.Core/Sers.Core/Module/Api/LocalApi/LocalApiService/LocalApiService.cs

@@ -20,15 +20,15 @@ namespace Sers.Core.Module.Api.LocalApi
     {
 
         /// <summary>
-        /// 后台服务的线程个数（单位个，默认0,代表不开启服务）(appsettings.json :: Sers.LocalApiService.workThreadCount)
+        /// 后台服务的线程个数（单位个，0代表不开启服务）(appsettings.json :: Sers.LocalApiService.workThread.threadCount)
         /// </summary>
-        public int workThreadCount { get => workThread.workThreadCount; set => workThread.workThreadCount = value; }
+        public int threadCount { get => workThread.threadCount; set => workThread.threadCount = value; }
 
         public LocalApiService()
         {
             workThread = ConsumerFactory.CreateConsumer<RequestInfo>(ConfigurationManager.Instance.GetByPath<JObject>("Sers.LocalApiService.workThread"));
 
-            workThread.name = "LocalApiService";
+            workThread.threadName = "LocalApiService";
             workThread.processor = Consumer_Processor;
             workThread.OnFinish = Consumer_OnFinish;
             workThread.OnTimeout = Consumer_OnTimeout;
@@ -170,13 +170,13 @@ namespace Sers.Core.Module.Api.LocalApi
 
         bool Consumer_Start()
         {
-            if (workThread.IsRunning) return false;
+            if (workThread.isRunning) return false;
             try
             {
-                if (workThreadCount > 0)
+                if (threadCount > 0)
                 {
                     workThread.Start();
-                    Logger.Info("[LocalApiService] Started,workThreadCount:" + workThreadCount);
+                    Logger.Info("[LocalApiService] Started,threadCount:" + threadCount);
 
                 }
                 return true;
@@ -191,7 +191,7 @@ namespace Sers.Core.Module.Api.LocalApi
 
         void Consumer_Stop()
         {
-            if (!workThread.IsRunning) return;
+            if (!workThread.isRunning) return;
 
             try
             {

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/ConsumerFactory.cs

@@ -1,4 +1,5 @@
 using Newtonsoft.Json.Linq;
+using Sers.Core.Util.Consumer.Mode;
 
 namespace Sers.Core.Util.Consumer
 {
@@ -10,18 +11,24 @@ namespace Sers.Core.Util.Consumer
 
             IConsumer<T> consumer;
             switch (config["mode"].ToString())
-            {               
-                case "BlockingCollection":
-                    consumer = new LongTask<T>();  //16 16 440万          2  2  800万
+            {
+                case "AsyncTask":
+                    consumer = new AsyncTask<T>();
                     break;
-                case "ConsumerCache_BlockingCollection":
-                    consumer = new ConsumerCascade<T, LongTask<T>>(); //16 16 4200-4500万
+                case "ConsumerCascade":
+                    consumer = new ConsumerCascade<T, LongTask<T>>();
+                    break;
+                case "LongTask":
+                    consumer = new LongTask<T>();
+                    break;
+                case "LongTask_TimeLimit":
+                    consumer = new LongTask_TimeLimit<T>();
                     break;
-
                 default:
                     consumer = new LongTask<T>();
                     break;
             }
+
             consumer.Init(config);
 
             return consumer;

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/IConsumer.cs

@@ -6,11 +6,11 @@ namespace Sers.Core.Util.Consumer
     public interface IConsumer<T>
     {
 
-        bool IsRunning { get; }
+        bool isRunning { get; }
 
-        int workThreadCount { get; set; }
+        int threadCount { get; set; }
 
-        string name { get; set; }
+        string threadName { get; set; }
 
         Action<T> processor { get; set; }
 

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/Mode/AsyncTask.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Vit.Core.Util.Threading;
+using Vit.Extensions;
 
 namespace Sers.Core.Util.Consumer.Mode
 {
@@ -12,23 +13,23 @@ namespace Sers.Core.Util.Consumer.Mode
     /// 
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class Async<T>: IConsumer<T>
+    public class AsyncTask<T>: IConsumer<T>
     {
 
         BlockingCollection<T> queue = new BlockingCollection<T>();
  
 
 
-        public string name { get; set; }
+        public string threadName { get; set; }
 
 
-        public int workThreadCount { get; set; }
+        public int threadCount { get; set; } = 1000;
 
 
         /// <summary>
         ///  超时时间。脉冲间隔。（主动关闭超过此时间的任务,实际任务强制关闭的时间会在1倍超时时间到2倍超时时间内)。单位：ms。(默认300000)
         /// </summary>
-        public int timeout_ms { get; set; }
+        public int timeout_ms { get; set; } = 300000;
 
         public Action<T> processor { get; set; }
         public Action<T> OnFinish { get; set; }
@@ -36,10 +37,12 @@ namespace Sers.Core.Util.Consumer.Mode
 
 
 
-        public bool IsRunning { get; set; }
+        public bool isRunning { get; set; }
 
         public void Init(JObject config)
         {
+            threadCount = config["threadCount"]?.Deserialize<int?>() ?? 1000;
+            timeout_ms = config["timeoutMs"]?.Deserialize<int?>() ?? 300000;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/Mode/ConsumerCascade.cs

@@ -3,6 +3,7 @@ using System;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using Vit.Extensions;
 
 namespace Sers.Core.Util.Consumer
 {
@@ -15,9 +16,9 @@ namespace Sers.Core.Util.Consumer
         where Consumer:IConsumer<T>,new()
     {
 
-        public int workThreadCount { get; set; } = 2;
+        public int threadCount { get; set; } = 16;
 
-        public string name { get; set; }
+        public string threadName { get; set; }
 
 
         public Action<T> processor { get; set; }
@@ -31,23 +32,30 @@ namespace Sers.Core.Util.Consumer
 
 
 
-        public bool IsRunning { get; private set; } = false;
+        public bool isRunning { get; private set; } = false;
 
+        JObject config;
         public void Init(JObject config)
         {
+            this.config = config;
+            threadCount = config["threadCount"]?.Deserialize<int?>() ?? 16;
         }
 
         public void Start()
         {
-            if (IsRunning) return;
-            IsRunning = true;
+            if (isRunning) return;
+            isRunning = true;
 
 
-            rootWorkerList = Enumerable.Range(0, workThreadCount).Select(m =>
+            rootWorkerList = Enumerable.Range(0, threadCount).Select(m =>
             {
                 var worker = new Consumer();
+                worker.Init(config);
                 worker.processor = processor;
-                worker.workThreadCount = 1;
+                worker.OnFinish = OnFinish;
+                worker.OnTimeout = OnTimeout;
+                worker.threadCount = 1;
+                worker.threadName = threadName;
                 //worker.Start();
                 return worker;
             }).ToArray();
@@ -60,8 +68,8 @@ namespace Sers.Core.Util.Consumer
 
         public void Stop()
         {
-            if (!IsRunning) return;
-            IsRunning = false;
+            if (!isRunning) return;
+            isRunning = false;
 
             rootWorkerList?.ToList().ForEach(m => m.Stop());
             rootWorkerList = null;

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/Mode/LongTask.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using Vit.Core.Module.Log;
 using Vit.Core.Util.Threading;
+using Vit.Extensions;
 
 namespace Sers.Core.Util.Consumer
 {
@@ -12,13 +13,13 @@ namespace Sers.Core.Util.Consumer
     /// qps : 260万   producer:16    consumer:16
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class LongTask<T>: IConsumer<T>
+    public class LongTask<T> : IConsumer<T>
     {
 
-        public int workThreadCount { get; set; } = 16;
+        public string threadName { get => task.threadName; set => task.threadName = value; }
 
-        public string name { get; set; }
 
+        public int threadCount { get => task.threadCount; set => task.threadCount = value; }
 
         public Action<T> processor { get; set; }
         public Action<T> OnFinish { get; set; }
@@ -28,11 +29,12 @@ namespace Sers.Core.Util.Consumer
         BlockingCollection<T> queue = new BlockingCollection<T>();
         LongTaskHelp task = new LongTaskHelp();
 
-        public bool IsRunning { get => task.IsRunning; }
+        public bool isRunning { get => task.IsRunning; }
 
 
         public void Init(JObject config)
-        {
+        { 
+            threadCount = config["threadCount"]?.Deserialize<int?>() ?? 16;
         }
 
 
@@ -47,8 +49,8 @@ namespace Sers.Core.Util.Consumer
         { 
             task.Stop();
 
-            task.threadName = name;
-            task.threadCount = workThreadCount;
+            task.threadName = threadName;
+            task.threadCount = threadCount;
             task.action = Processor;
             task.Start();
         }

dotnet/Library/Sers/Sers.Core/Sers.Core/Util/Consumer/Mode/LongTask_TimeLimit.cs

@@ -3,6 +3,7 @@ using System;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using Vit.Core.Util.Threading;
+using Vit.Extensions;
 
 namespace Sers.Core.Util.Consumer.Mode
 {
@@ -16,10 +17,10 @@ namespace Sers.Core.Util.Consumer.Mode
         LongTaskHelp_TimeLimit task = new LongTaskHelp_TimeLimit();
 
 
-        public string name { get => task.threadName; set => task.threadName = value; }
+        public string threadName { get => task.threadName; set => task.threadName = value; }
 
 
-        public int workThreadCount { get => task.threadCount; set => task.threadCount = value; }
+        public int threadCount { get => task.threadCount; set => task.threadCount = value; }
 
 
         /// <summary>
@@ -33,10 +34,12 @@ namespace Sers.Core.Util.Consumer.Mode
 
 
 
-        public bool IsRunning { get => task.IsRunning; }
+        public bool isRunning { get => task.IsRunning; }
 
         public void Init(JObject config)
         {
+            threadCount = config["threadCount"]?.Deserialize<int?>() ?? 1;
+            timeout_ms = config["timeoutMs"]?.Deserialize<int?>() ?? 300000;     
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

dotnet/Library/Sers/Sers.Core/Test/Sers.Core.Module.LocalApi.MsTest/LocalApi/LocalApiTest.cs

@@ -18,7 +18,7 @@ namespace Sers.Core.Module.LocalApi.MsTest.LocalApi
 
                 //(x.1)构建
                 LocalApiService localApiService = LocalApiServiceFactory.CreateLocalApiService() as LocalApiService;
-                localApiService.workThreadCount = 1;
+                localApiService.threadCount = 1;
                 localApiService.LoadSersApi(this.GetType().Assembly);
 
                 try

dotnet/Library/Sers/Sers.Core/Test/Sers.Core.Module.LocalApi.Qps/LocalApi/LocalApiTest.cs

@@ -10,7 +10,7 @@ namespace Sers.Core.Module.LocalApi.MsTest.LocalApi
     public class LocalApiTest
     {        
     
-        public static int workThreadCount = 4;
+        public static int threadCount = 4;
 
         static StatisticsQpsAsync statisticsQps = new StatisticsQpsAsync();
         static LocalApiService localApiService;
@@ -18,7 +18,7 @@ namespace Sers.Core.Module.LocalApi.MsTest.LocalApi
         {
             //(x.1)构建
             localApiService = LocalApiServiceFactory.CreateLocalApiService() as LocalApiService;
-            localApiService.workThreadCount = workThreadCount; 
+            localApiService.threadCount = threadCount; 
             localApiService.LoadSersApi(typeof(LocalApiTest).Assembly);
 
             localApiService.Start();

dotnet/Library/Sers/Sers.Core/Test/Sers.Core.Module.LocalApi.Qps/Program.cs

@@ -17,13 +17,13 @@ namespace DeliveryTest
             try
             {
                 
-                LocalApiTest.workThreadCount = 16;
+                LocalApiTest.threadCount = 16;
                 int requestTreadCount = 32;
                 if (args != null)
                 {
                     if (args.Length >=1)
                     {
-                        int.TryParse(args[0], out LocalApiTest.workThreadCount);
+                        int.TryParse(args[0], out LocalApiTest.threadCount);
                     }
 
                     if (args.Length >= 2)

dotnet/Library/Sers/Sers.Core/Test/Sers.Core.Util.Consumer.Test/ProgramQps.cs

@@ -124,7 +124,7 @@ namespace CLClient
 
 
             consumer.processor = Processor;
-            consumer.workThreadCount = consumerThreadCount;
+            consumer.threadCount = consumerThreadCount;
             consumer.Start();
 
 

dotnet/ServiceCenter/App.Gover.Gateway/wwwroot/_gover_/ActiveApiDoc.html

@@ -175,7 +175,9 @@
                             var html = '<a href="?" title="所有">所有</a> | ';
                             var data = apiRet.data;
                             for (var t in data) {
-                                var stationName = data[t].stationName;
+                                var station = data[t];
+                                if (station.activeApiNodeCount == 0) continue;
+                                var stationName = station.stationName;
                                 html += '<a href="?r=' + stationName + '" title="' + stationName + '">' + stationName + '</a> | ';
                             }
                             $('#apiStation').html(html);

dotnet/ServiceCenter/App.ServiceCenter/appsettings.json

@@ -6,16 +6,16 @@
       "Config": {
 
         "workThread": {
-
-          "mode": "",
-          /* 后台处理消息的线程个数（单位个，默认2） */
+          // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+          "mode": "LongTask",
+          /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
           "threadCount": 2,
-          /* 请求超时时间（单位ms，默认300000） */
+          /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
           "timeoutMs": 300000
-
-
         },
 
+        /* 请求超时时间（单位ms，默认300000） */
+        "requestTimeoutMs": 300000,
 
         //HeartBeat
         /* 心跳检测时间间隔（单位ms，默认10000,若指定为0则不进行心跳检测） */
@@ -192,16 +192,18 @@
     /* LocalApiService 配置,可不指定 */
     "LocalApiService": {
 
-      /* 后台服务的线程个数（单位个，默认0,代表不开启服务）*/
-      "workThreadCount": 4,
-
-      /* 超时时间，若不指定则后台任务永不超时。（主动关闭超过此时间的任务,实际任务强制关闭的时间会在1倍超时时间到2倍超时时间内)。单位：ms。*/
-      //"timeout_ms": 300000,
-
-
       /* 是否 输出本地Api的调用信息到（ApiTrace）Log文件。默认:false */
       "PrintTrace": false,
 
+      "workThread": {
+        // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+        "mode": "LongTask",
+        /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
+        "//threadCount": 16,
+        /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
+        "timeoutMs": 300000
+      },
+
 
       /* 静态文件映射器。映射站点静态文件，可多个,可不指定 */
       "//staticFiles": [

dotnet/ServiceStation/Demo/SersLoader/Did.SersLoader.Demo/appsettings.json

@@ -6,16 +6,18 @@
       /* 共用配置，子项共用，覆写子项未指定的配置 */
       "Config": {
 
+        "workThread": {
+          // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+          "mode": "LongTask_TimeLimit",
+          /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
+          "threadCount": 2,
+          /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
+          "timeoutMs": 300000
+        },
+
         /* 请求超时时间（单位ms，默认300000） */
         "requestTimeoutMs": 300000,
 
-        /* 后台处理消息的线程个数（单位个，默认2） */
-        "workThreadCount": 2,
-
-        /* 队列模式,可不指定。可为 BlockingCollection(默认)、 ConsumerCache_BlockingCollection(高性能) */
-        "ConsumerMode": "BlockingCollection",
-
-
 
         //HeartBeat
         /* 心跳检测时间间隔（单位ms，默认10000,若指定为0则不进行心跳检测） */
@@ -179,16 +181,18 @@
     /* LocalApiService 配置,可不指定 */
     "LocalApiService": {
 
-      /* 后台服务的线程个数（单位个，默认0,代表不开启服务）*/
-      "workThreadCount": 4,
-
-      /* 超时时间，若不指定则后台任务永不超时。（主动关闭超过此时间的任务,实际任务强制关闭的时间会在1倍超时时间到2倍超时时间内)。单位：ms。*/
-      //"timeout_ms": 300000,
-
-
       /* 是否 输出本地Api的调用信息到（ApiTrace）Log文件。默认:false */
       "PrintTrace": false,
 
+      "workThread": {
+        // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+        "mode": "LongTask",
+        /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
+        "//threadCount": 16,
+        /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
+        "timeoutMs": 300000
+      },
+
 
       /* 静态文件映射器。映射站点静态文件，可多个,可不指定 */
       "//staticFiles": [

dotnet/ServiceStation/Demo/Serslot/Did.Serslot.Demo/appsettings.json

@@ -17,6 +17,26 @@
   "Sers": {
     /* 通讯层配置 */
     "CL": {
+      /* 共用配置，子项共用，覆写子项未指定的配置 */
+      "Config": {
+
+        "workThread": {
+          // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+          "mode": "LongTask_TimeLimit",
+          /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
+          "threadCount": 2,
+          /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
+          "timeoutMs": 300000
+        },
+
+        /* 请求超时时间（单位ms，默认300000） */
+        "requestTimeoutMs": 300000,
+
+
+        /* 连接秘钥，用以验证连接安全性。服务端和客户端必须一致 */
+        "secretKey": "SersCL"
+
+      },
       /* one conn is one channel.can be multiable */
       "Client": [
         {
@@ -32,11 +52,8 @@
           /* 服务端 host地址。例如： "127.0.0.1"、"sers.cloud" */
           "host": "127.0.0.1",
           /* 服务端 监听端口号。例如： 4501 */
-          "port": 4501,
-
+          "port": 4501
 
-          /* 连接秘钥，用以验证连接安全性。服务端和客户端必须一致 */
-          "secretKey": "SersCL"
         }
       ]
     },
@@ -51,17 +68,18 @@
     /* LocalApiService 配置,可不指定 */
     "LocalApiService": {
 
-      /* 后台服务的线程个数（单位个，默认0,代表不开启服务） */
-      "workThreadCount": 4,
-
-
-      /* 超时时间，若不指定则后台任务永不超时。（主动关闭超过此时间的任务,实际任务强制关闭的时间会在1倍超时时间到2倍超时时间内)。单位：ms。*/
-      "//timeout_ms": 300000,
-
-
       /* 是否 输出本地Api的调用信息到（ApiTrace）Log文件。默认:false */
       "PrintTrace": false,
 
+      "workThread": {
+        // 模式，可为 LongTask（默认）、LongTask_TimeLimit、AsyncTask、ConsumerCascade。对应threadCount默认值分别为： 16、16、1000、16
+        "mode": "LongTask",
+        /* 后台处理消息的线程个数（单位个）(0代表不开启服务) */
+        "//threadCount": 16,
+        /* 请求超时时间（单位ms，默认300000），仅当mode为LongTask_TimeLimit、AsyncTask时有效 */
+        "timeoutMs": 300000
+      },
+
 
       /* 静态文件映射器。映射站点静态文件，可多个,可不指定 */
       "//staticFiles": [