如何在 C# 中启动带参数的线程？
【问题讨论】：
标签： c# multithreading
Thread 构造函数的 2 个重载之一采用 ParameterizedThreadStart 委托，它允许您将单个参数传递给 start 方法。不幸的是，尽管它只允许一个参数并且它以不安全的方式这样做，因为它将它作为对象传递。我发现使用 lambda 表达式来捕获相关参数并以强类型方式传递它们要容易得多。
试试下面的
public Thread StartTheThread(SomeType param1, SomeOtherType param2) {
var t = new Thread(() => RealStart(param1, param2));
t.Start();
return t;
}
private static void RealStart(SomeType param1, SomeOtherType param2) {
...
}
【讨论】：
Dim thr As New Thread(Sub() DoStuff(settings))
是的：
Thread t = new Thread (new ParameterizedThreadStart(myMethod));
t.Start (myParameterObject);
【讨论】：
void MyParamObject(object myUrl){ //do stuff }应该有参数类型object
ParameterizedThreadStart 并且从问题文本中清楚地看出，情况可能并非如此。
你可以使用 lambda 表达式
private void MyMethod(string param1,int param2)
{
//do stuff
}
Thread myNewThread = new Thread(() => MyMethod("param1",5));
myNewThread.Start();
这是迄今为止我能找到的最佳答案，它既快速又简单。
【讨论】：
Thread thread = new Thread(Work);
thread.Start(Parameter);
private void Work(object param)
{
string Parameter = (string)param;
}
参数类型必须是对象。
编辑：
虽然这个答案并不正确，但我建议不要使用这种方法。使用 lambda 表达式更容易阅读，并且不需要类型转换。见这里：https://stackoverflow.com/a/1195915/52551
【讨论】：
Parameter？
class Program
{
static void Main(string[] args)
{
Thread t = new Thread(new ParameterizedThreadStart(ThreadMethod));
t.Start("My Parameter");
}
static void ThreadMethod(object parameter)
{
// parameter equals to "My Parameter"
}
}
【讨论】：
像这样使用 lambda 的简单方法..
Thread t = new Thread(() => DoSomething("param1", "param2"));
t.Start();
或者你甚至可以像这样使用ThreadStart delegate...
private void DoSomething(int param1, string param2)
{
//DO SOMETHING...
ThreadStart ts = delegate
{
if (param1 > 0) DoSomethingElse(param2, "param3");
};
new Thread(ts).Start();
//DO SOMETHING...
}
OR 使用 .NET 4.5+ 甚至更干净……
private void DoSomething(int param1, string param2)
{
//DO SOMETHING..
void ts()
{
if (param1 > 0) DoSomethingElse(param2, "param3");
}
new Thread(ts).Start();
//DO SOMETHING..
}
【讨论】：
正如这里的各种答案中已经提到的那样，Thread 类目前（4.7.2）提供了几个 constructors 和一个 Start 具有重载的方法。
这个问题的相关构造函数是：
public Thread(ThreadStart start);
和
public Thread(ParameterizedThreadStart start);
接受ThreadStart 代表或ParameterizedThreadStart 代表。
对应的委托如下：
public delegate void ThreadStart();
public delegate void ParameterizedThreadStart(object obj);
因此可以看出，要使用的正确构造函数似乎是采用ParameterizedThreadStart 委托的构造函数，以便线程可以启动符合委托指定签名的某些方法。
实例化Thread 类的一个简单示例是
Thread thread = new Thread(new ParameterizedThreadStart(Work));
或者只是
Thread thread = new Thread(Work);
相应方法的签名（在本例中称为Work）如下所示：
private void Work(object data)
{
...
}
剩下的就是启动线程了。这是通过使用任一
public void Start();
或
public void Start(object parameter);
虽然Start() 将启动线程并将null 作为数据传递给方法，但Start(...) 可用于将任何东西 传递给线程的Work 方法。 p>
然而，这种方法存在一个大问题：
传入Work 方法的所有内容都被转换为一个对象。这意味着在 Work 方法中，它必须再次转换为原始类型，如下例所示：
public static void Main(string[] args)
{
Thread thread = new Thread(Work);
thread.Start("I've got some text");
Console.ReadLine();
}
private static void Work(object data)
{
string message = (string)data; // Wow, this is ugly
Console.WriteLine($"I, the thread write: {message}");
}
铸造是您通常不想做的事情。
如果有人传递了其他不是字符串的东西怎么办？因为一开始这似乎是不可能的（因为这是我的方法，我知道我在做什么或该方法是私有的，有人怎么能将任何东西传递给它？）由于各种原因，您可能最终会遇到这种情况。由于某些情况可能不是问题，其他情况是。在这种情况下，您最终可能会得到一个 InvalidCastException，您可能不会注意到它，因为它只是终止了线程。
作为一种解决方案，您希望获得一个通用的ParameterizedThreadStart 委托，例如ParameterizedThreadStart<T>，其中T 是您要传递给Work 方法的数据类型。不幸的是，这样的东西不存在（还没有？）。
然而，这个问题有一个suggested solution。它涉及创建一个类，该类包含要传递给线程的数据以及表示工作方法的方法，如下所示：
public class ThreadWithState
{
private string message;
public ThreadWithState(string message)
{
this.message = message;
}
public void Work()
{
Console.WriteLine($"I, the thread write: {this.message}");
}
}
使用这种方法，您可以像这样启动线程：
ThreadWithState tws = new ThreadWithState("I've got some text");
Thread thread = new Thread(tws.Work);
thread.Start();
因此，通过这种方式，您可以简单地避免强制转换，并以一种类型安全的方式向线程提供数据；-)
【讨论】：
private static void MyMethod<T>(T myData) { T message = myData; Console.WriteLine($"the thread wrote: {message}"); }
message.Length 是不可能的等等）
if(myData.GetType() == typeof(string)) { var str = ((string)(object)myData).Length; }，您可以使用 message.GetType() 并进行转换。无论如何，而不是使用你的线程方法，我发现使用Tasks<T> 更舒服，例如tasks.Add(Task.Run(() => Calculate(par1, par2, par3)))，请参阅下面的答案（stackoverflow.com/a/59777250/7586301）
我在传递的参数中遇到问题。 我将整数从 for 循环传递给函数并显示它，但它总是给出不同的结果。像 (1,2,2,3) (1,2,3,3) (1,1,2,3) 等带有 ParametrizedThreadStart 委托。
这个简单的代码很有魅力
Thread thread = new Thread(Work);
thread.Start(Parameter);
private void Work(object param)
{
string Parameter = (string)param;
}
【讨论】：
ParameterizedThreadStart 接受一个参数。您可以使用它来发送一个参数，或包含多个属性的自定义类。
另一种方法是将要作为实例成员启动的方法与要设置的参数的属性一起放入类中。创建类的实例，设置属性并启动指定实例和方法的线程，方法可以访问属性。
【讨论】：
您可以使用ParametrizedThreadStart 委托：
string parameter = "Hello world!";
Thread t = new Thread(new ParameterizedThreadStart(MyMethod));
t.Start(parameter);
【讨论】：
您可以使用BackgroundWorker RunWorkerAsync 方法并传入您的值。
【讨论】：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace ConsoleApp6
{
class Program
{
static void Main(string[] args)
{
int x = 10;
Thread t1 =new Thread(new ParameterizedThreadStart(order1));
t1.IsBackground = true;//i can stope
t1.Start(x);
Thread t2=new Thread(order2);
t2.Priority = ThreadPriority.Highest;
t2.Start();
Console.ReadKey();
}//Main
static void order1(object args)
{
int x = (int)args;
for (int i = 0; i < x; i++)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(i.ToString() + " ");
}
}
static void order2()
{
for (int i = 100; i > 0; i--)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(i.ToString() + " ");
}
}`enter code here`
}
}
【讨论】：
我建议使用Task<T>而不是Thread；它允许多个参数并且执行得非常好。
这是一个工作示例：
public static void Main()
{
List<Task> tasks = new List<Task>();
Console.WriteLine("Awaiting threads to finished...");
string par1 = "foo";
string par2 = "boo";
int par3 = 3;
for (int i = 0; i < 1000; i++)
{
tasks.Add(Task.Run(() => Calculate(par1, par2, par3)));
}
Task.WaitAll(tasks.ToArray());
Console.WriteLine("All threads finished!");
}
static bool Calculate1(string par1, string par2, int par3)
{
lock(_locker)
{
//...
return true;
}
}
// if need to lock, use this:
private static Object _locker = new Object();"
static bool Calculate2(string par1, string par2, int par3)
{
lock(_locker)
{
//...
return true;
}
}
【讨论】：
使用 lambda 表达式的一个非常简单方便的方法可以是这样的：
Thread thread = new Thread( (param) => {
string name = param as string;
// rest of code goes here.
});
thread.Start("MyName");
这样 lambda 表达式可以有参数并在单独的线程中运行内联代码。
【讨论】：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace ConsoleApp6
{
class Program
{
static void Main(string[] args)
{
int x = 10;
Thread t1 =new Thread(new ParameterizedThreadStart(order1));
t1.Start(x);
Thread t2=new Thread(order2);
t2.Priority = ThreadPriority.Highest;
t2.Start();
Console.ReadKey();
}//Main
static void order1(object args)
{
int x = (int)args;
for (int i = 0; i < x; i++)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(i.ToString() + " ");
}
}
static void order2()
{
for (int i = 100; i > 0; i--)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(i.ToString() + " ");
}
}
}
}
【讨论】：