多线程执行static方法，传入参数会覆盖吗

不会覆盖。

在Java中，静态方法是属于类的，而不是属于某个实例对象的。因此，无论你用多少个线程同时执行静态方法，它们都是在同一个类上执行。

因此，如果你在多个线程中同时调用同一个静态方法，并传入不同的参数，它们不会相互覆盖。每个线程都将创建自己的方法调用栈，每个栈都有自己的方法参数和局部变量，因此它们不会互相干扰。

相关问题

C#使用Thread创建一个多线程任务，多线程任务需要传入参数，当多线程任务执行3秒钟后，再执行后面的代码逻辑，要怎么说实现？

在C#中，要创建一个多线程任务并传入参数，可以使用`Thread`类或者更现代的`Task`类。在这个场景中，如果你要等待线程执行3秒钟后继续执行后面的代码逻辑，可以使用`Task`类结合`Task.Wait`或`Task.Result`来实现。下面是一个简单的示例：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // 参数
        string parameter = "Hello Thread";

        // 创建并启动一个任务
        Task task = Task.Run(() =>
        {
            // 任务代码
            Console.WriteLine($"任务开始执行，参数是：{parameter}");

            // 模拟执行3秒钟
            Thread.Sleep(3000);

            Console.WriteLine("任务执行了3秒钟");
        });

        // 等待任务执行完毕或等待3秒钟
        if (!task.Wait(3000))
        {
            Console.WriteLine("等待3秒钟结束，但任务可能还未执行完毕。");
        }

        // 执行后面的代码逻辑
        Console.WriteLine("任务执行完毕，继续执行后面的代码逻辑。");
    }
}

在这个例子中，`Task.Run`用于启动一个新的任务，该任务接受一个lambda表达式作为委托。在任务内部，使用`Thread.Sleep(3000)`来模拟任务执行3秒钟的操作。`task.Wait(3000)`会等待任务最多3秒钟，如果在这段时间内任务未完成，则继续执行后面的代码。

请注意，通常不推荐在主线程中等待后台线程，因为这可能会导致死锁或UI线程阻塞。在实际应用中，应考虑使用异步编程模式，避免长时间阻塞主线程。

.net framework 1.1如何多线程执行带参数的方法？

### 回答1：
您好，针对您的问题，您可以使用System.Threading.Thread类的Start方法来启动多线程，并通过ThreadStart委托来指定要执行的方法。如果您需要向该方法传递参数，您可以使用ParameterizedThreadStart委托来代替ThreadStart委托，并将参数作为Object类型的数组传递。

以下是一个使用ParameterizedThreadStart委托并传递参数的示例代码：

using System.Threading;

class Program
{
    static void Main(string[] args)
    {
        // 创建线程并传递参数
        Thread newThread = new Thread(new ParameterizedThreadStart(DoWork));
        newThread.Start("Hello World");
    }

    static void DoWork(object data)
    {
        // 获取传递的参数
        string message = (string)data;

        // 在这里编写您要执行的多线程方法的代码
    }
}

希望对您有所帮助。

### 回答2：
在.NET Framework 1.1中，可以使用Thread类来实现多线程执行带参数的方法。

首先，创建一个ThreadStart委托，并将要执行的方法作为参数传递给ThreadStart的构造函数。该方法可以带有参数，例如：

public class MyClass
{
    public void MyMethod(string param)
    {
        Console.WriteLine("执行带参数的方法，参数值为：" + param);
    }
}

接下来，创建一个Thread对象，并使用ThreadStart委托来初始化该对象。传入的方法名字必须是不带参数的方法名，即不包含任何参数：

MyClass myObject = new MyClass();
ThreadStart threadStart = new ThreadStart(myObject.MyMethod);

Thread thread = new Thread(threadStart);

要执行带参数的方法，可以使用ParameterizedThreadStart委托。ParameterizedThreadStart委托接受一个参数，从而允许传递参数给该方法：

public class MyClass
{
    public void MyMethod(object param)
    {
        string parameter = (string)param;
        Console.WriteLine("执行带参数的方法，参数值为：" + parameter);
    }
}

然后，创建一个Thread对象，并使用ParameterizedThreadStart委托来初始化该对象。传入的方法名字必须是不带参数的方法名，即不包含任何参数。

MyClass myObject = new MyClass();
ParameterizedThreadStart parameterizedThreadStart = new ParameterizedThreadStart(myObject.MyMethod);

Thread thread = new Thread(parameterizedThreadStart);

最后，可以使用Start方法启动线程，并传递参数：

thread.Start("参数值");

通过以上步骤，就可以在.NET Framework 1.1中实现多线程执行带参数的方法。

### 回答3：
在.NET Framework 1.1中，可以使用Thread类的实例来实现多线程执行带参数的方法。下面是一个简单的示例：

首先，定义一个带参数的方法，例如以下的add方法：

static void Add(object param)
{
    int num = (int)param;
    int result = num + 1;
    Console.WriteLine("加1后的结果是：" + result);
}

然后，在主线程中创建并启动新的线程，将参数传递给add方法：

int param = 10;
Thread thread = new Thread(new ParameterizedThreadStart(Add));
thread.Start(param);

在上述示例中，我们首先创建了一个int类型的参数param，将它的值设为10。然后，我们通过Thread类的构造函数创建一个新的线程，并将Add方法作为参数传递给它。注意，我们使用了ParameterizedThreadStart委托，它可以接收一个参数。最后，我们通过调用thread的Start方法启动新线程，并将param传递给它。

当新线程开始执行时，带参数的Add方法会被调用，并将传递的参数强制转换为int类型的变量num。在这个例子中，num的值为10。接下来，将num加1，并将结果打印到控制台。

这样，我们就实现了在.NET Framework 1.1中多线程执行带参数的方法。请注意，这只是一个简单的示例，真实的应用可能会涉及更复杂的逻辑和多个参数。