C#中ThreadStart委托的实现

目录

• 1.ThreadStart 委托：
• 2. 典型使用场景
• (1) 多任务队列管理
• (2) 延迟执行控制
• 3. 技术细节
• 委托与线程的关系
• 线程安全注意事项
•  4. 完整使用示例
• 5. 替代方案（现代C#推荐）
• 使用 Task 和 ConcurrentQueue
• 优点
• 6. 关键区别：ThreadStart vs Action
• 总结

1.ThreadStart 委托：

ThreadStart 是 .NET 中的一个内置委托类型，表示无参数且无返回值的方法。其定义如下：

public delegate void ThreadStart();

• 通常用于定义线程的入口方法。

• List<ThreadStart>：

  这是一个泛型集合，用于存储多个 ThreadStart 委托实例。每python个委托代表一个待执行的任务。

• 整体作用：

  创建一个线程任务队列，用于保存需要通过线程执行的多个方法。

2. 典型使用场景

private List<ThreadStart> delegates = new List<ThreadStart>();

(1) 多任务队列管理

// 添加任务到队列
delegates.Add(() => Console.Writehttp://www.devze.comLine("Task 1"));
delegates.Add(() => File.WriteAllText("test.txt", "Hello"));

// 启动线程执行所有任务
foreach (var task in delegates)
{
    new Thread(task).Start();
}

(2) 延迟执行控制

// 先收集任务
delegates.Add(() => DownloadFile(url1));
delegates.Add(() => ProcessData(data));

// 在适当时候触发执行
vwww.devze.comoid ExecuteAllTasks()
{
    foreach (var task in delegates)
    {
        new Thread(task).Start();
    }
}

3. 技术细节

委托与线程的关系

• 每个 ThreadStart 委托可以传递给 Thread 构造函数，作为线程启动时执行的方法。

• 示例：

ThreadStart task = () => Console.WriteLine("Running in thread");
Thread thread = new Thread(task);
thread.Start();

线程安全注意事项

• 非线程安全集合：

  List<T> 本身不是线程安全的。若多线程同时修改集合（如添加/删除任务），需加锁：

private readonly object _lock = new object();

void AddTask(ThreadStart task)
{
    lock (_lock)
    {
        delegates.Add(task);
    }
}

 4. 完整使用示例

using System;
using System.Collections.Generic;
using System.Threading;

class TaskScheduler
{
    private List<ThreadStart> _tasks = new List<ThreadStart>();
    private readonly object _lock = new object();

    public void AddTask(Action action)
    {
        lock (_lock)
        {
            _tasks.Add(new ThreadStart(action));
        }
    }

    public void ExecuteAll()
    {
        List<Thread> threads = new List<Thread>();
        
        lock (_lock)
        {
            foreach (var task in _tasks)
            {
                Thread thread = new Thread(task);
                threads.Add(thread);
                thread.Start();
            }
            _tasks.Clear();
        }

        // 等待所有线程完成（可选）
        foreach (var thread in threads)
        {
 http://www.devze.com           thread.Join();
        }
    }
}

// 使用示例
var scheduler = new TaskScheduler();
scheduler.AddTask(() => Console.WriteLine("Task 1"));
scheduler.AddTask(() => Thread.Sleep(1000));
scheduler.ExecuteAll();

5. 替代方案（现代C#推荐）

使用 Task 和 ConcurrentQueue

using System.Collections.Concurrent;
using System.Threading.Tasks;

private ConcurrentQueue<Action> _taskQueue = new ConcurrentQueue<Action>();

// 添加任务
_taskQueue.Enqueue(() => Console.WriteLine("Task 1"));

// 并行执行
Parallel.ForEach(_taskQueue, task => task.Invoke());
_taskQueue.Clear();

优点

• 更高效的线程池管理（通过 Task）

• 天生线程安全的集合（ConcurrentQueue）

• 支持 async/await

6. 关键区别：ThreadStart vs Action

总结

• 原始代码：创建了一个传统的线程任务队列，适用于需要显式管理 Thread 的场景。

• 现代替代：推荐使用 Task + ConcurrentQueue 组合，更符合当前 .NET 的并发编程最佳实践。

• 线程安全：若坚持使用 List&kOOuMpClDlt;ThreadStart>，必须通过锁机制保证线程安全。

根据实际需求选择合适方案，平衡控制精细度和开发效率。

到此这篇关于C#中ThreadStart委托的实现的文章就介绍到这了,更多相关C# ThreadStart委托内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！