为什么@Asynchronous和Future类不起作用

我试图调用返回Future对象的异步方法，我假设它将打印YYY，然后打印XXX，因为XXX位于一个1秒长的方法中。然而，在部署代码后，它不能正常工作，我用10个对象尝试了同样的方法，它们按顺序打印。错误在哪里

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package testfuture;


import java.net.InetAddress;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import javax.ejb.Asynchronous;

import javax.ejb.Schedule;
import javax.ejb.Singleton;
import javax.ejb.TransactionManagement;
import javax.ejb.TransactionManagementType;

@Singleton
@TransactionManagement(TransactionManagementType.BEAN)
public class TestFuture {

    @Schedule(minute = "*/1", hour = "*", persistent = false)
    public void start()  {

                try{
                    Future<String> r = inparallelMethod(5) ;
                    System.out.print("YYY");
                    r.get();
                }
                catch ( InterruptedException ie )
                {
                    System.out.print(ie.getMessage());
                }
                catch (ExecutionException e)
                {
                     System.out.print(e.getMessage());
                }


        }

    @Asynchronous
    public Future<String> inparallelMethod(int i) throws InterruptedException
    {

        Thread.sleep(1000);
        System.out.print("XXX");
        return null;
    }


}

/*
*要更改此许可证标题，请在“项目属性”中选择“许可证标题”。
*要更改此模板文件，请选择工具|模板
*然后在编辑器中打开模板。
*/
包装测试未来；
导入java.net.InetAddress；
导入java.util.List；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.Future；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
导入javax.ejb.Asynchronous；
导入javax.ejb.Schedule；
导入javax.ejb.Singleton；
导入javax.ejb.TransactionManagement；
导入javax.ejb.TransactionManagementType；
@独生子女
@TransactionManagement（TransactionManagementType.BEAN）
公共类测试未来{
@时间表（分钟=“*/1”，小时=“*”，持续=假）
公开作废开始（）{
试一试{
未来r=平行法（5）；
系统输出打印（“YYY”）；
r、 get（）；
}
捕获（中断异常ie）
{
System.out.print（即getMessage（））；
}
捕获（执行例外）
{
System.out.print（如getMessage（））；
}
}
@异步的
公共未来并行方法（int i）抛出InterruptedException
{
睡眠（1000）；
系统输出打印（“XXX”）；
返回null；
}
}

因为您在实例化类中调用inparallelMethod“bybassing”容器管理调用异步方法的方法

您必须在另一个bean中定义异步方法，@注入该bean并调用该方法

@Singleton
@TransactionManagement(TransactionManagementType.BEAN)    
public class TestFuture {

    @Inject
    AsyncService service;

    @Schedule(minute = "*/1", hour = "*", persistent = false)
    public void start()  {

                try{
                    Future<String> r = service.inparallelMethod(5) ;
                    System.out.print("YYY");
                    r.get();
                }
                catch ( InterruptedException ie )
                {
                    System.out.print(ie.getMessage());
                }
                catch (ExecutionException e)
                {
                     System.out.print(e.getMessage());
                }


        }
}

@Stateless
public class AsyncService {

    @Asynchronous
    public Future<String> inparallelMethod(int i) throws InterruptedException
    {

        Thread.sleep(1000);
        System.out.print("XXX");
        return null;
    }


}

@Singleton
@TransactionManagement（TransactionManagementType.BEAN）
公共类测试未来{
@注入
异步服务；
@时间表（分钟=“*/1”，小时=“*”，持续=假）
公开作废开始（）{
试一试{
未来r=服务。并行方法（5）；
系统输出打印（“YYY”）；
r、 get（）；
}
捕获（中断异常ie）
{
System.out.print（即getMessage（））；
}
捕获（执行例外）
{
System.out.print（如getMessage（））；
}
}
}
@无国籍
公共类异步服务{
@异步的
公共未来并行方法（int i）抛出InterruptedException
{
睡眠（1000）；
系统输出打印（“XXX”）；
返回null；
}
}

---

我发布代码是为了使异步工作，但是您的代码在测试异步场景时非常糟糕，Thread.sleep在java ee中是一个非常糟糕的做法，因为线程是由容器管理的，您不知道您真正在睡哪个线程

因为您在实例化类内调用inparallelMethod“bybassing”容器管理调用异步方法的方法

您必须在另一个bean中定义异步方法，@注入该bean并调用该方法

@Singleton
@TransactionManagement(TransactionManagementType.BEAN)    
public class TestFuture {

    @Inject
    AsyncService service;

    @Schedule(minute = "*/1", hour = "*", persistent = false)
    public void start()  {

                try{
                    Future<String> r = service.inparallelMethod(5) ;
                    System.out.print("YYY");
                    r.get();
                }
                catch ( InterruptedException ie )
                {
                    System.out.print(ie.getMessage());
                }
                catch (ExecutionException e)
                {
                     System.out.print(e.getMessage());
                }


        }
}

@Stateless
public class AsyncService {

    @Asynchronous
    public Future<String> inparallelMethod(int i) throws InterruptedException
    {

        Thread.sleep(1000);
        System.out.print("XXX");
        return null;
    }


}

@Singleton
@TransactionManagement（TransactionManagementType.BEAN）
公共类测试未来{
@注入
异步服务；
@时间表（分钟=“*/1”，小时=“*”，持续=假）
公开作废开始（）{
试一试{
未来r=服务。并行方法（5）；
系统输出打印（“YYY”）；
r、 get（）；
}
捕获（中断异常ie）
{
System.out.print（即getMessage（））；
}
捕获（执行例外）
{
System.out.print（如getMessage（））；
}
}
}
@无国籍
公共类异步服务{
@异步的
公共未来并行方法（int i）抛出InterruptedException
{
睡眠（1000）；
系统输出打印（“XXX”）；
返回null；
}
}

我发布代码是为了使异步工作，但是您的代码在测试异步场景时非常糟糕，Thread.sleep在java ee中是一个非常糟糕的做法，因为线程是由容器管理的，您不知道您真正在睡哪个线程