Show me a java example multithead call funt

### 回答1：
下面是一个使用 Java 实现多线程调用方法的示例：

public class MultiThreadExample {
   public static void main(String[] args) {
      // 创建两个线程
      Thread thread1 = new Thread(new Task("Thread 1"));
      Thread thread2 = new Thread(new Task("Thread 2"));

      // 启动两个线程
      thread1.start();
      thread2.start();
   }
}

class Task implements Runnable {
   private String name;

   public Task(String name) {
      this.name = name;
   }

   @Override
   public void run() {
      for (int i = 0; i < 5; i++) {
         System.out.println(name + " is running iteration " + i);
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

在这个示例中，我们创建了两个线程，并通过实现 `Runnable` 接口并重写 `run` 方法实现了两个线程的行为。最后，我们通过调用 `thread1.start()` 和 `thread2.start()` 来启动这两个线程。

### 回答2：
以下是一个Java多线程调用函数的示例：

public class MultithreadExample {

    public static void main(String[] args) {
        // 创建一个Runnable对象
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        };

        // 创建并启动三个线程分别调用该函数
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        Thread thread3 = new Thread(task);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

上述代码中，我们首先创建了一个实现了Runnable接口的任务（即函数），任务会输出当前运行线程的名称以及计数器的值。

然后，我们创建了三个线程thread1、thread2和thread3，并将任务分配给它们。最后，我们分别启动这三个线程。

当程序执行时，每个线程都会独立运行任务，并输出各自的线程名称和计数器的值。由于是多线程调用同一个函数，所以输出的结果可能会交错，但总体上会保持各个线程连续地输出自己的值。

注意：多线程编程需要注意线程安全和同步的问题，以确保多个线程正确地访问和操作共享资源。

### 回答3：
这是一个Java多线程调用函数的示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MultiThreadExample {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 创建Callable对象
        Callable<Integer> task = () -> {
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
                sum += i;
            }
            return sum;
        };

        // 提交任务并获取Future对象
        Future<Integer> future1 = executor.submit(task);
        Future<Integer> future2 = executor.submit(task);

        try {
            // 获取结果并输出
            int result1 = future1.get();
            int result2 = future2.get();
            System.out.println("线程1的计算结果：" + result1);
            System.out.println("线程2的计算结果：" + result2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }
}

以上示例中创建了一个固定大小为5的线程池，然后定义了一个可调用的任务`task`，这个任务会计算从1到10的累加和。然后通过`executor.submit(task)`方法将任务提交给线程池，返回一个`Future`对象，表示异步的计算结果。

通过`future.get()`方法可以获取每个线程返回的结果，在示例中分别输出了线程1和线程2的计算结果。

最后调用`executor.shutdown()`方法关闭线程池。