如何用Java在同一个类中并发运行2个方法

我想在同一个类中同时使用Java中的同一对象使用两个方法。例如：

public class aThread extends Thread {

    int countA = 0;
    int countB = 0;

    int countA(){
        for (int i = 0; i < 1000; i++) {
            countA++;
        }
        return countA;
    }
    int countB(){
        for (int i = 0; i < 1000; i++) {
            countB++;
        }
        return countB;
    }
    @Override
    public void run() {
        super.run(); 
        //should there be something here?
    }
}

---

注意：它们不必同步。

您需要创建可运行文件来调用您试图在独立线程中并发运行的方法

public static void main(String[] args) {
  final aThread myThread = new aThread();

  Runnable a = new Runnable() {
    public void run() {
      myThread.countA();
    }
  });
  Runnable b = new Runnable() {
    public void run() {
      myThread.countB();
    }
  });
    new Thread(a).start();
    new Thread(b).start();
}

---

有几种方法可以完成你的任务。当线程不应该同步时，您会遇到一个非常容易的情况

您可以从Java并发中使用：

public class ConcurrentCode {
    
    private int countA = 0;
    private int countB = 0;
    
    int countA(){
        for (int i = 0; i < 1000; i++) {
            countA++;
        }
        System.out.println(countA);
        return countA;
    }
    
    int countB(){
        for (int i = 0; i < 1000; i++) {
            countB++;
        }
        System.out.println(countB);
        return countB;
    }
    
    public void execute(){
        ExecutorService executorService = Executors.newFixedThreadPool(2);
    
        // method reference introduced in Java 8
        executorService.submit(this::countA);
        executorService.submit(this::countB);
    
        // close executorService
        executorService.shutdown();
    }
    
    
    public static void main(String[] args){
        new ConcurrentCode().execute();
    }
    
}

要获得计算结果，您可以从

executorService

获取，然后您可以选择：

• 轮询

  Future

  是否完成
• 等待

  将来的
  操作完成

• 明确等待某个超时

以下是一个例子：

public void execute() throws Exception {
    ExecutorService executorService = Executors.newFixedThreadPool(2);

    Future<Integer> future1 = executorService.submit(this::countA);
    Future<Integer> future2 = executorService.submit(this::countB);

    // wait until result will be ready
    Integer result1 = future1.get();

    // wait only certain timeout otherwise throw an exception
    Integer result2 = future2.get(1, TimeUnit.SECONDS);

    System.out.println("result1 = " + result1);
    System.out.println("result2 = " + result2);

    executorService.shutdown();
}

public void execute（）引发异常{
ExecutorService ExecutorService=Executors.newFixedThreadPool（2）；
Future future1=executorService.submit（this:：countA）；
Future future2=executorService.submit（this:：countB）；
//等待结果准备就绪
整数result1=future1.get（）；
//仅等待特定超时，否则将引发异常
整数result2=future2.get（1，时间单位为秒）；
System.out.println（“result1=“+result1”）；
System.out.println（“result2=“+result2”）；
executorService.shutdown（）；
}

注意，当我们显式地等待

future1

的结果时，

future2

仍在另一个线程中执行。这意味着在本例中，未来2的计算不会有很大的延迟

---

另外，请查看异步计算中使用的线程。

要同时运行代码，至少需要两个线程：

public class MyClass {

    int countA = 0;
    int countB = 0;

    public int countA(){
        for (int i = 0; i < 1000; i++) {
            countA++;
        }
        return countA;
    }

    public int countB(){
        for (int i = 0; i < 1000; i++) {
            countB++;
        }
        return countB;
    }

    public static void main(String[] args) throws Exception{
        MyClass myClass = new MyClass() ;
        ExecutorService  executorService = Executors.newFixedThreadPool(2) ;
        List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>() ;
        tasks.add(myClass::countA) ;
        tasks.add(myClass::countB) ;
        List<Future<Integer>> results = executorService.invokeAll(tasks) ;
        System.out.println(results.get(0).get()+" "+results.get(1).get());
        executorService.shutdown();
    }
}

公共类MyClass{
int countA=0；
int countB=0；
公共int countA（）{
对于（int i=0；i<1000；i++）{
countA++；
}
返回计数a；
}
公共int countB（）{
对于（int i=0；i<1000；i++）{
countB++；
}
返回计数b；
}
公共静态void main（字符串[]args）引发异常{
MyClass MyClass=新的MyClass（）；
ExecutorService ExecutorService=Executors.newFixedThreadPool（2）；
列表任务=新建ArrayList（）；
添加（myClass:：countA）；
添加（myClass:：countB）；
列表结果=executorService.invokeAll（任务）；
System.out.println（results.get（0.get（）+“”+results.get（1.get（））；
executorService.shutdown（）；
}
}

---

您可以使用：results.

解决方案使用

Stream

API跟踪结果

异步：

public void并行运行（可运行…任务）{
Stream.of（tasks）.map（Thread:：new）.forEach（Thread:：start）；
}

同步：

public void并行运行（可运行…任务）{
Stream.of（tasks）.parallel（）.forEach（Runnable:：run）；
}

如何使用：

public void execute（）{
并行运行(
这是……countA，
这是(b),；
}
public void executeWithParams（）{
并行运行(
（）->countA（5），
（）->countA（10））；
}

或者您可以使用lambda，或者更确切地说是方法引用：

新线程（myThread:：countA）.start（）值得注意：执行此操作时，类
aThread
不需要
扩展线程
。您忘记了方法的结果以及阻止您这样做的原因是什么？@OusmaneMahyDiaw，因为这两个方法不会同时运行。因为它们在系统的不同部分从同一对象使用。另外，有两个以上的方法，我不能一次只创建一个方法来调用它们。值得注意的是：在执行此操作时，Class
aThread
不需要
扩展线程。如何以这种方式检索值的返回？@EmreDanisan有几种方法可以实现这一点。您可以从
submit
方法中获取
Future
，然后轮询它们或等待响应准备就绪。我会更新我的answer@EmreDanisan快乐编码：）您忘记了方法的结果您可以使用：results跟踪结果。
public void execute() throws Exception {
    ExecutorService executorService = Executors.newFixedThreadPool(2);

    Future<Integer> future1 = executorService.submit(this::countA);
    Future<Integer> future2 = executorService.submit(this::countB);

    // wait until result will be ready
    Integer result1 = future1.get();

    // wait only certain timeout otherwise throw an exception
    Integer result2 = future2.get(1, TimeUnit.SECONDS);

    System.out.println("result1 = " + result1);
    System.out.println("result2 = " + result2);

    executorService.shutdown();
}

public class MyClass {

    int countA = 0;
    int countB = 0;

    public int countA(){
        for (int i = 0; i < 1000; i++) {
            countA++;
        }
        return countA;
    }

    public int countB(){
        for (int i = 0; i < 1000; i++) {
            countB++;
        }
        return countB;
    }

    public static void main(String[] args) throws Exception{
        MyClass myClass = new MyClass() ;
        ExecutorService  executorService = Executors.newFixedThreadPool(2) ;
        List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>() ;
        tasks.add(myClass::countA) ;
        tasks.add(myClass::countB) ;
        List<Future<Integer>> results = executorService.invokeAll(tasks) ;
        System.out.println(results.get(0).get()+" "+results.get(1).get());
        executorService.shutdown();
    }
}