< Summary

Information
Class: Ice.Internal.ThreadPool
Assembly: Ice
File(s): /_/csharp/src/Ice/Internal/ThreadPool.cs
Tag: 91_21789722663
Line coverage
71%
Covered lines: 237
Uncovered lines: 94
Coverable lines: 331
Total lines: 770
Line coverage: 71.6%
Branch coverage
70%
Covered branches: 112
Total branches: 158
Branch coverage: 70.8%
Method coverage
83%
Covered methods: 25
Total methods: 30
Method coverage: 83.3%

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)57.14%66.52863.38%
destroy()50%2.01285.71%
updateObservers()100%22100%
initialize(...)100%11100%
register(...)100%11100%
update(...)100%1010100%
unregister(...)100%11100%
finish(...)100%22100%
executeFromThisThread(...)50%5.4455.56%
execute(...)50%2.01287.5%
joinWithAllThreads()100%22100%
prefix()100%210%
serialize()100%210%
QueueTask(...)100%11100%
TryExecuteTaskInline(...)100%22100%
TryDequeue(...)100%210%
GetScheduledTasks()100%210%
queueReadyForIOHandler(...)100%11100%
run(...)71.88%78.053264.44%
ioCompleted(...)75%31.341660.87%
startMessage(...)79.17%26.672483.33%
finishMessage(...)87.5%8.13887.5%
getCallback(...)100%11100%
.ctor(...)100%11100%
updateObserver()100%44100%
setState(...)100%44100%
getThread()100%210%
join()100%11100%
start(...)50%2.01287.5%
Run()33.33%72.751225%

File(s)

/_/csharp/src/Ice/Internal/ThreadPool.cs

#LineLine coverage
 1// Copyright (c) ZeroC, Inc.
 2
 3using System.Diagnostics;
 4
 5namespace Ice.Internal;
 6
 7public delegate void ThreadPoolWorkItem(ThreadPoolCurrent current);
 8
 9public delegate void AsyncCallback(object state);
 10
 11internal class ThreadPoolMessage : IDisposable
 12{
 13    public ThreadPoolMessage(ThreadPoolCurrent current, object mutex)
 14    {
 15        _current = current;
 16        _mutex = mutex;
 17        _finish = false;
 18        _finishWithIO = false;
 19    }
 20
 21    public bool startIOScope()
 22    {
 23        // This must be called with the handler locked.
 24        _finishWithIO = _current.startMessage();
 25        return _finishWithIO;
 26    }
 27
 28    public void finishIOScope()
 29    {
 30        if (_finishWithIO)
 31        {
 32            // This must be called with the handler locked.
 33            _current.finishMessage();
 34        }
 35    }
 36
 37    public void ioCompleted()
 38    {
 39        //
 40        // Call finishMessage once IO is completed only if serialization is not enabled.
 41        // Otherwise, finishMessage will be called when the event handler is done with
 42        // the message (it will be called from Dispose below).
 43        //
 44        Debug.Assert(_finishWithIO);
 45        if (_current.ioCompleted())
 46        {
 47            _finishWithIO = false;
 48            _finish = true;
 49        }
 50    }
 51
 52    public void Dispose()
 53    {
 54        if (_finish)
 55        {
 56            //
 57            // A ThreadPoolMessage instance must be created outside the synchronization of the event handler. We
 58            // need to lock the event handler here to call finishMessage.
 59            //
 60            lock (_mutex)
 61            {
 62                _current.finishMessage();
 63            }
 64        }
 65    }
 66
 67    private readonly ThreadPoolCurrent _current;
 68    private readonly object _mutex;
 69    private bool _finish;
 70    private bool _finishWithIO;
 71}
 72
 73public class ThreadPoolCurrent
 74{
 75    internal ThreadPoolCurrent(ThreadPool threadPool, ThreadPool.WorkerThread thread)
 76    {
 77        _threadPool = threadPool;
 78        _thread = thread;
 79    }
 80
 81    public int operation;
 82
 83    public bool ioCompleted() => _threadPool.ioCompleted(this);
 84
 85    public bool startMessage() => _threadPool.startMessage(this);
 86
 87    public void finishMessage() => _threadPool.finishMessage(this);
 88
 89    internal readonly ThreadPool _threadPool;
 90    internal readonly ThreadPool.WorkerThread _thread;
 91    internal bool _ioCompleted;
 92    internal EventHandler _handler;
 93}
 94
 95public sealed class ThreadPool : System.Threading.Tasks.TaskScheduler
 96{
 197    public ThreadPool(Instance instance, string prefix, int timeout)
 98    {
 199        Ice.Properties properties = instance.initializationData().properties;
 100
 1101        _instance = instance;
 1102        _executor = instance.initializationData().executor;
 1103        _destroyed = false;
 1104        _prefix = prefix;
 1105        _threadIndex = 0;
 1106        _inUse = 0;
 1107        _serialize = properties.getPropertyAsInt(_prefix + ".Serialize") > 0;
 1108        _serverIdleTime = timeout <= 0 ? Timeout.InfiniteTimeSpan : TimeSpan.FromSeconds(timeout);
 109
 1110        string programName = properties.getIceProperty("Ice.ProgramName");
 1111        if (programName.Length > 0)
 112        {
 1113            _threadPrefix = programName + "-" + _prefix;
 114        }
 115        else
 116        {
 0117            _threadPrefix = _prefix;
 118        }
 119
 1120        int size = properties.getPropertyAsIntWithDefault(_prefix + ".Size", 1);
 1121        if (size < 1)
 122        {
 0123            string s = _prefix + ".Size < 1; Size adjusted to 1";
 0124            _instance.initializationData().logger.warning(s);
 0125            size = 1;
 126        }
 127
 1128        int sizeMax = properties.getPropertyAsIntWithDefault(_prefix + ".SizeMax", size);
 1129        if (sizeMax < size)
 130        {
 1131            string s = _prefix + ".SizeMax < " + _prefix + ".Size; SizeMax adjusted to Size (" + size + ")";
 1132            _instance.initializationData().logger.warning(s);
 1133            sizeMax = size;
 134        }
 135
 1136        int sizeWarn = properties.getPropertyAsInt(_prefix + ".SizeWarn");
 1137        if (sizeWarn != 0 && sizeWarn < size)
 138        {
 0139            string s = _prefix + ".SizeWarn < " + _prefix + ".Size; adjusted SizeWarn to Size (" + size + ")";
 0140            _instance.initializationData().logger.warning(s);
 0141            sizeWarn = size;
 142        }
 1143        else if (sizeWarn > sizeMax)
 144        {
 0145            string s = _prefix + ".SizeWarn > " + _prefix + ".SizeMax; adjusted SizeWarn to SizeMax ("
 0146                + sizeMax + ")";
 0147            _instance.initializationData().logger.warning(s);
 0148            sizeWarn = sizeMax;
 149        }
 150
 1151        int threadIdleTime = properties.getPropertyAsIntWithDefault(_prefix + ".ThreadIdleTime", 60);
 1152        if (threadIdleTime < 0)
 153        {
 0154            string s = _prefix + ".ThreadIdleTime < 0; ThreadIdleTime adjusted to 0";
 0155            _instance.initializationData().logger.warning(s);
 0156            threadIdleTime = 0;
 157        }
 158
 1159        _size = size;
 1160        _sizeMax = sizeMax;
 1161        _sizeWarn = sizeWarn;
 1162        _threadIdleTime = threadIdleTime <= 0 ? Timeout.InfiniteTimeSpan : TimeSpan.FromSeconds(threadIdleTime);
 163
 1164        int stackSize = properties.getPropertyAsInt(_prefix + ".StackSize");
 1165        if (stackSize < 0)
 166        {
 0167            string s = _prefix + ".StackSize < 0; Size adjusted to OS default";
 0168            _instance.initializationData().logger.warning(s);
 0169            stackSize = 0;
 170        }
 1171        _stackSize = stackSize;
 172
 1173        _priority = properties.getProperty(_prefix + ".ThreadPriority").Length > 0 ?
 1174            Util.stringToThreadPriority(properties.getProperty(_prefix + ".ThreadPriority")) :
 1175            Util.stringToThreadPriority(properties.getIceProperty("Ice.ThreadPriority"));
 176
 1177        if (_instance.traceLevels().threadPool >= 1)
 178        {
 0179            string s = "creating " + _prefix + ": Size = " + _size + ", SizeMax = " + _sizeMax + ", SizeWarn = " +
 0180                       _sizeWarn;
 0181            _instance.initializationData().logger.trace(_instance.traceLevels().threadPoolCat, s);
 182        }
 183
 1184        _workItems = new Queue<ThreadPoolWorkItem>();
 185
 186        try
 187        {
 1188            _threads = new List<WorkerThread>();
 1189            for (int i = 0; i < _size; ++i)
 190            {
 1191                var thread = new WorkerThread(this, _threadPrefix + "-" + _threadIndex++);
 1192                thread.start(_priority);
 1193                _threads.Add(thread);
 194            }
 1195        }
 0196        catch (System.Exception ex)
 197        {
 0198            string s = "cannot create thread for `" + _prefix + "':\n" + ex;
 0199            _instance.initializationData().logger.error(s);
 200
 0201            destroy();
 0202            joinWithAllThreads();
 0203            throw;
 204        }
 1205    }
 206
 207    public void destroy()
 208    {
 1209        lock (_mutex)
 210        {
 1211            if (_destroyed)
 212            {
 0213                return;
 214            }
 1215            _destroyed = true;
 1216            Monitor.PulseAll(_mutex);
 1217        }
 1218    }
 219
 220    public void updateObservers()
 221    {
 1222        lock (_mutex)
 223        {
 1224            foreach (WorkerThread t in _threads)
 225            {
 1226                t.updateObserver();
 227            }
 228        }
 1229    }
 230
 231    public void initialize(EventHandler handler)
 232    {
 1233        handler._ready = 0;
 1234        handler._pending = 0;
 1235        handler._started = 0;
 1236        handler._finish = false;
 1237        handler._hasMoreData = false;
 1238        handler._registered = 0;
 1239    }
 240
 1241    public void register(EventHandler handler, int op) => update(handler, SocketOperation.None, op);
 242
 243    public void update(EventHandler handler, int remove, int add)
 244    {
 1245        lock (_mutex)
 246        {
 247            Debug.Assert(!_destroyed);
 248
 249            // Don't remove what needs to be added
 1250            remove &= ~add;
 251
 252            // Don't remove/add if already un-registered or registered
 1253            remove &= handler._registered;
 1254            add &= ~handler._registered;
 1255            if (remove == add)
 256            {
 1257                return;
 258            }
 259
 1260            handler._registered &= ~remove;
 1261            handler._registered |= add;
 262
 1263            if ((add & SocketOperation.Read) != 0 && (handler._pending & SocketOperation.Read) == 0)
 264            {
 1265                handler._pending |= SocketOperation.Read;
 1266                queueReadyForIOHandler(handler, SocketOperation.Read);
 267            }
 1268            else if ((add & SocketOperation.Write) != 0 && (handler._pending & SocketOperation.Write) == 0)
 269            {
 1270                handler._pending |= SocketOperation.Write;
 1271                queueReadyForIOHandler(handler, SocketOperation.Write);
 272            }
 1273        }
 1274    }
 275
 1276    public void unregister(EventHandler handler, int op) => update(handler, op, SocketOperation.None);
 277
 278    public void finish(EventHandler handler)
 279    {
 1280        lock (_mutex)
 281        {
 282            Debug.Assert(!_destroyed);
 283
 1284            handler._registered = SocketOperation.None;
 285
 286            //
 287            // If there are no pending asynchronous operations, we can call finish on the handler now.
 288            //
 1289            if (handler._pending == 0)
 290            {
 1291                _workItems.Enqueue(current =>
 1292                    {
 1293                        current.operation = SocketOperation.None;
 1294                        current._handler = handler;
 1295                        handler.finished(current);
 1296                    });
 1297                Monitor.Pulse(_mutex);
 298            }
 299            else
 300            {
 1301                handler._finish = true;
 302            }
 1303        }
 1304    }
 305
 306    public void executeFromThisThread(System.Action call, Ice.Connection connection)
 307    {
 1308        if (_executor is not null)
 309        {
 310            try
 311            {
 1312                _executor(call, connection);
 1313            }
 0314            catch (System.Exception ex)
 315            {
 0316                if (_instance.initializationData().properties.getIcePropertyAsInt("Ice.Warn.Executor") > 0)
 317                {
 0318                    _instance.initializationData().logger.warning($"executor exception:\n{ex}");
 319                }
 0320            }
 321        }
 322        else
 323        {
 1324            call();
 325        }
 1326    }
 327
 328    public void execute(Action workItem, Ice.Connection connection)
 329    {
 1330        lock (_mutex)
 331        {
 1332            if (_destroyed)
 333            {
 0334                throw new Ice.CommunicatorDestroyedException();
 335            }
 1336            _workItems.Enqueue(current =>
 1337                {
 1338                    current.ioCompleted();
 1339                    executeFromThisThread(workItem, connection);
 1340                });
 1341            Monitor.Pulse(_mutex);
 1342        }
 1343    }
 344
 345    public void joinWithAllThreads()
 346    {
 347        //
 348        // _threads is immutable after destroy() has been called, therefore no synchronization is needed.
 349        // (Synchronization wouldn't be possible here anyway, because otherwise the other threads would never
 350        // terminate.)
 351        //
 352        Debug.Assert(_destroyed);
 1353        foreach (WorkerThread thread in _threads)
 354        {
 1355            thread.join();
 356        }
 1357    }
 358
 0359    public string prefix() => _prefix;
 360
 0361    public bool serialize() => _serialize;
 362
 363    protected sealed override void QueueTask(
 1364        System.Threading.Tasks.Task task) => execute(
 1365            () => TryExecuteTask(task),
 1366            null);
 367
 368    protected sealed override bool TryExecuteTaskInline(System.Threading.Tasks.Task task, bool taskWasPreviouslyQueued)
 369    {
 1370        if (!taskWasPreviouslyQueued)
 371        {
 1372            executeFromThisThread(() => TryExecuteTask(task), null);
 1373            return true;
 374        }
 1375        return false;
 376    }
 377
 0378    protected sealed override bool TryDequeue(System.Threading.Tasks.Task task) => false;
 379
 380    protected sealed override IEnumerable<System.Threading.Tasks.Task> GetScheduledTasks() =>
 0381        Array.Empty<System.Threading.Tasks.Task>();
 382
 383    private void queueReadyForIOHandler(EventHandler handler, int operation)
 384    {
 1385        lock (_mutex)
 386        {
 387            Debug.Assert(!_destroyed);
 1388            _workItems.Enqueue(current =>
 1389                {
 1390                    current._handler = handler;
 1391                    current.operation = operation;
 1392                    try
 1393                    {
 1394                        current._handler.message(current);
 1395                    }
 0396                    catch (System.Exception ex)
 1397                    {
 0398                        string s = "exception in `" + _prefix + "':\n" + ex + "\nevent handler: " +
 0399                            current._handler.ToString();
 0400                        _instance.initializationData().logger.error(s);
 0401                    }
 1402                });
 1403            Monitor.Pulse(_mutex);
 1404        }
 1405    }
 406
 407    private void run(WorkerThread thread)
 408    {
 1409        var current = new ThreadPoolCurrent(this, thread);
 410        while (true)
 411        {
 1412            ThreadPoolWorkItem workItem = null;
 1413            lock (_mutex)
 414            {
 1415                while (_workItems.Count == 0)
 416                {
 1417                    if (_destroyed)
 418                    {
 1419                        return;
 420                    }
 421
 1422                    if (_threadIdleTime != Timeout.InfiniteTimeSpan)
 423                    {
 1424                        if (!Monitor.Wait(_mutex, _threadIdleTime) && _workItems.Count == 0) // If timeout
 425                        {
 1426                            if (_destroyed)
 427                            {
 0428                                return;
 429                            }
 1430                            else if (_inUse < _threads.Count - 1)
 431                            {
 0432                                if (_instance.traceLevels().threadPool >= 1)
 433                                {
 0434                                    string s = "shrinking " + _prefix + ": Size=" + (_threads.Count - 1);
 0435                                    _instance.initializationData().logger.trace(
 0436                                        _instance.traceLevels().threadPoolCat, s);
 437                                }
 438
 0439                                _threads.Remove(thread);
 0440                                _workItems.Enqueue(c =>
 0441                                        // No call to ioCompleted, this shouldn't block (and we don't want to cause
 0442                                        // a new thread to be started).
 0443                                        thread.join());
 0444                                Monitor.Pulse(_mutex);
 0445                                return;
 446                            }
 1447                            else if (_inUse > 0)
 448                            {
 449                                //
 450                                // If this is the last idle thread but there are still other threads
 451                                // busy dispatching, we go back waiting with _threadIdleTime. We only
 452                                // wait with _serverIdleTime when there's only one thread left.
 453                                //
 454                                continue;
 455                            }
 456
 457                            Debug.Assert(_threads.Count == 1);
 1458                            if (!Monitor.Wait(_mutex, _serverIdleTime) && !_destroyed)
 459                            {
 1460                                _workItems.Enqueue(c =>
 1461                                    {
 1462                                        c.ioCompleted();
 1463                                        try
 1464                                        {
 1465                                            _instance.objectAdapterFactory().shutdown();
 1466                                        }
 0467                                        catch (Ice.CommunicatorDestroyedException)
 1468                                        {
 0469                                        }
 1470                                    });
 471                            }
 472                        }
 473                    }
 474                    else
 475                    {
 0476                        Monitor.Wait(_mutex);
 477                    }
 478                }
 479
 480                Debug.Assert(_workItems.Count > 0);
 1481                workItem = _workItems.Dequeue();
 482
 1483                current._thread.setState(Ice.Instrumentation.ThreadState.ThreadStateInUseForIO);
 1484                current._ioCompleted = false;
 1485            }
 486
 487            try
 488            {
 1489                workItem(current);
 1490            }
 0491            catch (System.Exception ex)
 492            {
 0493                string s = "exception in `" + _prefix + "' while calling on work item:\n" + ex + '\n';
 0494                _instance.initializationData().logger.error(s);
 0495            }
 496
 1497            lock (_mutex)
 498            {
 1499                if (_sizeMax > 1 && current._ioCompleted)
 500                {
 501                    Debug.Assert(_inUse > 0);
 1502                    --_inUse;
 503                }
 1504                thread.setState(Ice.Instrumentation.ThreadState.ThreadStateIdle);
 1505            }
 506        }
 1507    }
 508
 509    public bool ioCompleted(ThreadPoolCurrent current)
 510    {
 1511        lock (_mutex)
 512        {
 1513            current._ioCompleted = true; // Set the IO completed flag to specify that ioCompleted() has been called.
 514
 1515            current._thread.setState(Ice.Instrumentation.ThreadState.ThreadStateInUseForUser);
 516
 1517            if (_sizeMax > 1)
 518            {
 519                Debug.Assert(_inUse >= 0);
 1520                ++_inUse;
 521
 1522                if (_sizeMax > 1 && _inUse == _sizeWarn)
 523                {
 0524                    string s = "thread pool `" + _prefix + "' is running low on threads\n"
 0525                        + "Size=" + _size + ", " + "SizeMax=" + _sizeMax + ", " + "SizeWarn=" + _sizeWarn;
 0526                    _instance.initializationData().logger.warning(s);
 527                }
 528
 1529                if (!_destroyed && _inUse < _sizeMax && _inUse == _threads.Count)
 530                {
 1531                    if (_instance.traceLevels().threadPool >= 1)
 532                    {
 0533                        string s = "growing " + _prefix + ": Size = " + (_threads.Count + 1);
 0534                        _instance.initializationData().logger.trace(_instance.traceLevels().threadPoolCat, s);
 535                    }
 536
 537                    try
 538                    {
 1539                        var t = new WorkerThread(this, _threadPrefix + "-" + _threadIndex++);
 1540                        t.start(_priority);
 1541                        _threads.Add(t);
 1542                    }
 0543                    catch (System.Exception ex)
 544                    {
 0545                        string s = "cannot create thread for `" + _prefix + "':\n" + ex;
 0546                        _instance.initializationData().logger.error(s);
 0547                    }
 548                }
 549            }
 1550        }
 1551        return _serialize;
 552    }
 553
 554    public bool startMessage(ThreadPoolCurrent current)
 555    {
 556        Debug.Assert((current._handler._pending & current.operation) != 0);
 557
 1558        if ((current._handler._started & current.operation) != 0)
 559        {
 560            Debug.Assert((current._handler._ready & current.operation) == 0);
 1561            current._handler._ready |= current.operation;
 1562            current._handler._started &= ~current.operation;
 1563            if (!current._handler.finishAsync(current.operation)) // Returns false if the handler is finished.
 564            {
 1565                current._handler._pending &= ~current.operation;
 1566                if (current._handler._pending == 0 && current._handler._finish)
 567                {
 1568                    finish(current._handler);
 569                }
 1570                return false;
 571            }
 572        }
 1573        else if ((current._handler._ready & current.operation) == 0 &&
 1574                (current._handler._registered & current.operation) != 0)
 575        {
 576            Debug.Assert((current._handler._started & current.operation) == 0);
 1577            if (!current._handler.startAsync(current.operation, getCallback(current.operation)))
 578            {
 0579                current._handler._pending &= ~current.operation;
 0580                if (current._handler._pending == 0 && current._handler._finish)
 581                {
 0582                    finish(current._handler);
 583                }
 0584                return false;
 585            }
 586            else
 587            {
 1588                current._handler._started |= current.operation;
 1589                return false;
 590            }
 591        }
 592
 1593        if ((current._handler._registered & current.operation) != 0)
 594        {
 595            Debug.Assert((current._handler._ready & current.operation) != 0);
 1596            current._handler._ready &= ~current.operation;
 1597            return true;
 598        }
 599        else
 600        {
 1601            current._handler._pending &= ~current.operation;
 1602            if (current._handler._pending == 0 && current._handler._finish)
 603            {
 1604                finish(current._handler);
 605            }
 1606            return false;
 607        }
 608    }
 609
 610    public void finishMessage(ThreadPoolCurrent current)
 611    {
 1612        if ((current._handler._registered & current.operation) != 0)
 613        {
 614            Debug.Assert((current._handler._ready & current.operation) == 0);
 1615            if (!current._handler.startAsync(current.operation, getCallback(current.operation)))
 616            {
 0617                current._handler._pending &= ~current.operation;
 618            }
 619            else
 620            {
 621                Debug.Assert((current._handler._pending & current.operation) != 0);
 1622                current._handler._started |= current.operation;
 623            }
 624        }
 625        else
 626        {
 1627            current._handler._pending &= ~current.operation;
 628        }
 629
 1630        if (current._handler._pending == 0 && current._handler._finish)
 631        {
 632            // There are no more pending async operations, it's time to call finish.
 1633            finish(current._handler);
 634        }
 1635    }
 636
 637    private AsyncCallback getCallback(int operation)
 638    {
 639        Debug.Assert(operation == SocketOperation.Read || operation == SocketOperation.Write);
 1640        return state => queueReadyForIOHandler((EventHandler)state, operation);
 641    }
 642
 643    private readonly Instance _instance;
 644    private readonly System.Action<System.Action, Ice.Connection> _executor;
 645    private bool _destroyed;
 646    private readonly string _prefix;
 647    private readonly string _threadPrefix;
 648
 1649    private readonly object _mutex = new object();
 650
 651    internal sealed class WorkerThread
 652    {
 653        private readonly ThreadPool _threadPool;
 654        private Ice.Instrumentation.ThreadObserver _observer;
 655        private Ice.Instrumentation.ThreadState _state;
 656
 1657        internal WorkerThread(ThreadPool threadPool, string name)
 658        {
 1659            _threadPool = threadPool;
 1660            _name = name;
 1661            _state = Ice.Instrumentation.ThreadState.ThreadStateIdle;
 1662            updateObserver();
 1663        }
 664
 665        public void updateObserver()
 666        {
 667            // Must be called with the thread pool mutex locked
 1668            Ice.Instrumentation.CommunicatorObserver obsv = _threadPool._instance.initializationData().observer;
 1669            if (obsv is not null)
 670            {
 1671                _observer = obsv.getThreadObserver(_threadPool._prefix, _name, _state, _observer);
 1672                _observer?.attach();
 673            }
 1674        }
 675
 676        public void setState(Ice.Instrumentation.ThreadState s)
 677        {
 678            // Must be called with the thread pool mutex locked
 1679            if (_observer is not null)
 680            {
 1681                if (_state != s)
 682                {
 1683                    _observer.stateChanged(_state, s);
 684                }
 685            }
 1686            _state = s;
 1687        }
 688
 0689        public Thread getThread() => _thread;
 690
 1691        public void join() => _thread.Join();
 692
 693        public void start(ThreadPriority priority)
 694        {
 1695            if (_threadPool._stackSize == 0)
 696            {
 1697                _thread = new Thread(new ThreadStart(Run));
 698            }
 699            else
 700            {
 0701                _thread = new Thread(new ThreadStart(Run), _threadPool._stackSize);
 702            }
 1703            _thread.IsBackground = true;
 1704            _thread.Name = _name;
 1705            _thread.Priority = priority;
 1706            _thread.Start();
 1707        }
 708
 709        public void Run()
 710        {
 1711            if (_threadPool._instance.initializationData().threadStart is not null)
 712            {
 713                try
 714                {
 0715                    _threadPool._instance.initializationData().threadStart();
 0716                }
 0717                catch (System.Exception ex)
 718                {
 0719                    string s = "thread hook start() method raised an unexpected exception in `";
 0720                    s += _threadPool._prefix + "' thread " + _thread.Name + ":\n" + ex;
 0721                    _threadPool._instance.initializationData().logger.error(s);
 0722                }
 723            }
 724
 725            try
 726            {
 1727                _threadPool.run(this);
 1728            }
 0729            catch (System.Exception ex)
 730            {
 0731                string s = "exception in `" + _threadPool._prefix + "' thread " + _thread.Name + ":\n" + ex;
 0732                _threadPool._instance.initializationData().logger.error(s);
 0733            }
 734
 1735            _observer?.detach();
 736
 1737            if (_threadPool._instance.initializationData().threadStop is not null)
 738            {
 739                try
 740                {
 0741                    _threadPool._instance.initializationData().threadStop();
 0742                }
 0743                catch (System.Exception ex)
 744                {
 0745                    string s = "thread hook stop() method raised an unexpected exception in `";
 0746                    s += _threadPool._prefix + "' thread " + _thread.Name + ":\n" + ex;
 0747                    _threadPool._instance.initializationData().logger.error(s);
 0748                }
 749            }
 1750        }
 751
 752        private readonly string _name;
 753        private Thread _thread;
 754    }
 755
 756    private readonly int _size; // Number of threads that are pre-created.
 757    private readonly int _sizeMax; // Maximum number of threads.
 758    private readonly int _sizeWarn; // If _inUse reaches _sizeWarn, a "low on threads" warning will be printed.
 759    private readonly bool _serialize; // True if requests need to be serialized over the connection.
 760    private readonly ThreadPriority _priority;
 761    private readonly TimeSpan _serverIdleTime;
 762    private readonly TimeSpan _threadIdleTime;
 763    private readonly int _stackSize;
 764
 765    private readonly List<WorkerThread> _threads; // All threads, running or not.
 766    private int _threadIndex; // For assigning thread names.
 767    private int _inUse; // Number of threads that are currently in use.
 768
 769    private readonly Queue<ThreadPoolWorkItem> _workItems;
 770}
Generated by: ReportGenerator 5.3.8.0
02/08/2026 - 01:13:28
GitHub | reportgenerator.io

Methods/Properties

.ctor(Ice.Internal.Instance, string, int)
destroy()
updateObservers()
initialize(Ice.Internal.EventHandler)
register(Ice.Internal.EventHandler, int)
update(Ice.Internal.EventHandler, int, int)
unregister(Ice.Internal.EventHandler, int)
finish(Ice.Internal.EventHandler)
executeFromThisThread(System.Action, Ice.Connection)
execute(System.Action, Ice.Connection)
joinWithAllThreads()
prefix()
serialize()
QueueTask(System.Threading.Tasks.Task)
TryExecuteTaskInline(System.Threading.Tasks.Task, bool)
TryDequeue(System.Threading.Tasks.Task)
GetScheduledTasks()
queueReadyForIOHandler(Ice.Internal.EventHandler, int)
run(Ice.Internal.ThreadPool.WorkerThread)
ioCompleted(Ice.Internal.ThreadPoolCurrent)
startMessage(Ice.Internal.ThreadPoolCurrent)
finishMessage(Ice.Internal.ThreadPoolCurrent)
getCallback(int)
.ctor(Ice.Internal.ThreadPool, string)
updateObserver()
setState(Ice.Instrumentation.ThreadState)
getThread()
join()
start(System.Threading.ThreadPriority)
Run()