Java 如何用三个不同的线程调用同一个方法

假设我有一个名为Magic（）的方法，我想用三个不同的线程执行这个方法。 我知道如何使用单个线程执行Magic（）方法，但我很困惑，如何使用三个不同的线程

假设我有一个名为Magic（）的方法，我想用三个不同的线程执行这个方法

创建一个

MagicTask

类，该类表示每个

线程将执行的
任务，并在
run（）中调用
magic（）
方法：

然后创建三个线程并将任务传递给它：

Thread t1 = new Thread(new MagicTask());
Thread t2 = new Thread(new MagicTask());
Thread t3 = new Thread(new MagicTask());

然后启动线程：

t1.start();
t2.start();
t3.start();

注意您也可以将相同的
MagicTask
实例传递给所有三个
线程
实例。请记住，如果
MagicTask
的状态在被不同的线程访问时可能会变得不一致，那么您还需要使用
synchronized
或其他不属于此答案范围的此类构造来使用内部锁，从而使类线程安全。
直接调用它，就像
magic（）为了获得更好的结果，请像下面那样同步该方法

public synchronized void magic(){ 
              //your code 
}

这里线程t1、t2、t3正在调用相同的方法call（）。
import java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
类WorkerThread实现Runnable{
公开募捐{
魔术（）；
}
私人虚空魔法（）{
//考虑同步此方法，但如果方法，则一次可由一个线程访问。
}
}
公共类TestThreadPool{
公共静态void main（字符串[]args）{
ExecutorService executor=Executors.newFixedThreadPool（3）
对于（int i=0；i<3；i++）{
Runnable worker=new WorkerThread（）；
执行人，执行人（工人）；
}
executor.shutdown（）；
而（！executor.isTerminated（））{
}
}
}
如果您使用的是Java 8，函数引用非常简单：

public class Main {
    public static void magic() {
        System.out.println("this is magic");
    }

    public static void main(final String args[]) {
        new Thread(Main::magic).start();
        new Thread(Main::magic).start();
        new Thread(Main::magic).start();
    }
}

如果magic不是静态方法，请使用：

public class Main {
    public void magic() {
        System.out.println("this is magic");
    }

    public static void main(final String args[]) {
        Main m = new Main();

        new Thread(m::magic).start();
        new Thread(m::magic).start();
        new Thread(m::magic).start();
    }
}

你可以像这样试试。

我把任务分为不同的线程
试试你自己的逻辑它只是一个简单的偶数

public类CountNumber实现可运行{
int stop；
int启动；
int totalEvenNo；
公共计数编号（整数开始、整数停止）
{
这个。开始=开始；
这个。停止=停止；
}
公开募捐
{
整数总计=偶数（开始、停止）；
System.out.println（“偶数总数为：“+Total”）；
}
公共整数偶数（整数str，整数stp）
{
对于（int i=str；i必须调用它。假设每个线程都有一个不同或相同的对象实例，只需像正常情况一样调用它……您是否尝试过编码和运行它？请尝试并添加您的代码为什么您有一个名为
Magic
的方法？我们在Java中使用
camelCase
作为方法名。@varun这不是理想的方法。Can在逻辑上划分任务，使其能够同时运行。例如，如果要处理100条记录，则对每条记录执行相同的任务。然后，您可以将任务划分为多个线程，处理部分记录。我强烈建议您阅读此类作业的生产者-消费者模式。@varun，请使用同步块或方法，以便您的方法将通过锁为每个线程访问。因此，您将获得并发data@varun您可以向上投票并将其标记为已接受的答案：）。如果您有更多与您试图解决的实际问题相关的问题，请在网站上发布新问题，而不是编辑此问题，我将很乐意提供帮助。您可以研究此问题吗？此
System.out.println（totalEvenNo）
很可能是一种同步方法（虽然不能保证，但实际上是这样）。这意味着这段代码绝对没有并行化。它所做的只是创建多个线程，轮流打印-这轮流意味着代码不是并发的。如果使用Java 8，您将使用。这是基于神秘
线程
的代码和现代Java的奇怪混合体。这永远不会发生。作者希望知道如何用三个不同的线程调用同一个方法。我的解决方案很容易理解和维护。另一方面更复杂，更不直观。我的建议是：保持简单。这
而（！executor.isTerminated（））{}
是忙碌的等待。它在
while
上旋转一个
线程，在等待期间100%使用它-在等待期间将它从游戏中移除。现代代码永远不应该这样做。有很多方法可以使用适当的等待，例如@boristesspider。谢谢。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class WorkerThread implements Runnable {

     public void run() {

        Magic();
    }
    private void Magic() {
// consider synchronizing this method, but if you do method will be accessable by one thread at a time.
     }

}

public class TestThreadPool {
     public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3)
        for (int i = 0; i < 3; i++) {
            Runnable worker = new WorkerThread();
            executor.execute(worker);
          }
        executor.shutdown();
       while (!executor.isTerminated()) {}

            }
}
}

public class Main {
    public static void magic() {
        System.out.println("this is magic");
    }

    public static void main(final String args[]) {
        new Thread(Main::magic).start();
        new Thread(Main::magic).start();
        new Thread(Main::magic).start();
    }
}

public class Main {
    public void magic() {
        System.out.println("this is magic");
    }

    public static void main(final String args[]) {
        Main m = new Main();

        new Thread(m::magic).start();
        new Thread(m::magic).start();
        new Thread(m::magic).start();
    }
}

public class CountNumber implements Runnable {

    int stop;
    int start;
    int totalEvenNo;

    public CountNumber(int start, int stop)
    {
        this.start=start;
        this.stop=stop;
    }

    public void run()
    {
    int total=  countEven(start, stop);
    System.out.println("Total Even numbers are :"+total);
    }
    public int countEven(int str,int stp)
    {
        for(int i=str;i<=stp;i++)
        {
            if(i%2==0)
            {
                totalEvenNo +=1;
                System.out.println(totalEvenNo);
            }
        }
        return totalEvenNo;
    }
   }

public class MainClassNumber {

    public static void main(String[] args) {
        System.out.println("Spawaning Thread.........");

            Thread t1 = new Thread(new CountNumber(0, 500000));
            Thread t2 = new Thread(new CountNumber(500001, 2000000));
            Thread t3 = new Thread(new CountNumber(2000001, 5000000));
            Thread t4 = new Thread(new CountNumber(5000001, 10000000));
            Thread t5 = new Thread(new CountNumber(10000001, 20000000));
            t1.start();
            t2.start();
            t3.start();
            t4.start();
            t5.start();

    }

}