java 多线程执行不同的函数,在Java中使用多线程调用同一类的不同方法

I have a class as below with three methods

public class MyRunnable implements Runnable {

@Override

public void run() {

// what code need to write here

//to call the specific methods based on request types

}

public int add(int a, int b){

return a+b;

}

public int multiply(int a , int b){

return a*b;

}

public int division(int a , int b){

return a/b;

}

}

and my main class as blow

here r.multiply(), add() and division() methods will be executed sequentially, but i want to execute them in multi-threaded way hence i can get the result faster. how to call a method of a class dynamically based on inputs. how to pass to thread and how to return result from thread to calling thread.

public class ThreadDemo {

public static void main(String[] args) {

MyRunnable r = new MyRunnable();

// how to do below calculation using multihtreading

// how to call a method and how to get result of a thread of same class

int result = r.multiply(1, 2) + r.add(4, 5) + r.division(10, 5);

System.out.println(result);

int newResult = r.add(20, 50);

System.out.println(newResult);

}

}

解决方案

Multi-threading would slow down this application (because the amount of processing per step is far to small to justify the overhead of distributing the work across threads), the application probably finishes well before you perceive it anyway.

Assuming it's a simplified example you can write

MyRunnable r = new MyRunnable();

Executor exec = Executors.newFixedThreadPool(3);

CompletableFuture mult = CompletableFuture.runAsync(() -> r.multiply(1, 2),exec );

CompletableFuture add = CompletableFuture.runAsync(() -> r.add(4, 5) ,exec);

CompletableFuture div = CompletableFuture.runAsync(() -> r.division(10, 5),exec);

CompletableFuture result = mult.thenCombine(add, (multRes,addRes) -> multRes+addRest)

.thenCombine(div, (total,divRes) -> total+divRes);

int answer = result.join();

UPDATE Why use an explicitly defined Executor?

It shows readers how to explicitly define an executor (the alternative is straightforward)

By defining the Executor as a variable, you can switch between the Common ForkJoinPool (or any other executor type) by changing just that variable assignment (you don't have to refactor all of the methods). E.g.

//ForkJoinPool common

Executor exec = ForkJoinPool.commonPool();

//Expanding thread pool

Executor exec = Executors.newCachedThreadPool();

//Just execute on the current thread

Executor exec = (Runnable r) -> r.run();

By default CompletableFuture.*Async methods share the Common ForkJoinPool and so do Parallel Streams, along with ForkJoinTasks without a specific executor. Unless all members of the team think carefully about when to / not to use the Common ForkJoinPool you could end up mixing async I/O operations with CPU bound processing in the same pool accidentally.

Also by default, the parallelism is set to Runtime.getRuntime().availableProcessors() - 1. Which again, may or may not suit the use case at hand (for some users it might mean this example was single threaded). It is configurable via the System Property "java.util.concurrent.ForkJoinPool.common.parallelism", if you need to change the defaults.