在JSF托管bean中启动新线程是否安全？

时间：2011-05-27 08:53:30

标签： jsf concurrency java-ee ejb ejb-3.1

我无法找到一个明确的答案，确定在会话范围内的JSF托管bean中生成线程是否安全。线程需要调用无状态EJB实例上的方法（依赖注入到托管bean）。

背景是我们有一个需要很长时间才能生成的报告。这导致HTTP请求由于我们无法更改的服务器设置而超时。因此，我们的想法是启动一个新线程，让它生成报告并暂时存储它。与此同时，JSF页面显示了一个进度条，轮询托管bean直到生成完成，然后再发出第二个请求来下载存储的报告。这似乎有效，但我想确定我所做的不是黑客。

3 个答案:

答案 0 :(得分：52)

查看EJB 3.1 @Asynchronous methods。这正是它们的用途。

使用OpenEJB 4.0.0-SNAPSHOTs的小例子。这里我们有一个@Singleton bean，其中一个方法标记为@Asynchronous。每次任何人调用该方法时，在这种情况下你的JSF托管bean，无论方法实际花费多长时间，它都会立即返回。

@Singleton
public class JobProcessor {

    @Asynchronous
    @Lock(READ)
    @AccessTimeout(-1)
    public Future<String> addJob(String jobName) {

        // Pretend this job takes a while
        doSomeHeavyLifting();

        // Return our result
        return new AsyncResult<String>(jobName);
    }

    private void doSomeHeavyLifting() {
        try {
            Thread.sleep(SECONDS.toMillis(10));
        } catch (InterruptedException e) {
            Thread.interrupted();
            throw new IllegalStateException(e);
        }
    }
}

这是一个小的测试用例，它连续多次调用@Asynchronous方法。

每次调用都返回一个Future对象，该对象基本上以 empty 开始，并且稍后在相关方法调用实际完成时由容器填充其值。

import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class JobProcessorTest extends TestCase {

    public void test() throws Exception {

        final Context context = EJBContainer.createEJBContainer().getContext();

        final JobProcessor processor = (JobProcessor) context.lookup("java:global/async-methods/JobProcessor");

        final long start = System.nanoTime();

        // Queue up a bunch of work
        final Future<String> red = processor.addJob("red");
        final Future<String> orange = processor.addJob("orange");
        final Future<String> yellow = processor.addJob("yellow");
        final Future<String> green = processor.addJob("green");
        final Future<String> blue = processor.addJob("blue");
        final Future<String> violet = processor.addJob("violet");

        // Wait for the result -- 1 minute worth of work
        assertEquals("blue", blue.get());
        assertEquals("orange", orange.get());
        assertEquals("green", green.get());
        assertEquals("red", red.get());
        assertEquals("yellow", yellow.get());
        assertEquals("violet", violet.get());

        // How long did it take?
        final long total = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start);

        // Execution should be around 9 - 21 seconds
        assertTrue("" + total, total > 9);
        assertTrue("" + total, total < 21);
    }
}

Example source code

在幕后的内容是：

  • 来电者看到的JobProcessor实际上并不是JobProcessor的实例。相反，它是一个子类或代理，它覆盖了所有方法。应该是异步的方法以不同的方式处理。
  • 调用异步方法只会导致创建Runnable包装您提供的方法和参数。这个runnable被赋予Executor，它只是一个附加到线程池的工作队列。
  • 将工作添加到队列后，该方法的代理版本返回Future的实现，该实现链接到正在队列中等待的Runnable。
  • 当Runnable最终在真实 JobProcessor实例上执行该方法时，它将获取返回值并将其设置为Future使其可用致来电者。

重要的是要注意AsyncResult返回的JobProcessor对象与调用者持有的Future对象不同。如果真实的JobProcessor可以返回String并且来电者的JobProcessor版本可以返回Future<String>，那将会很简洁，但我们没有看到任何方法可以做到这一点没有增加更多复杂性。所以AsyncResult是一个简单的包装器对象。容器会将String拉出，抛出AsyncResult，然后将String放入调用者所持有的真实 Future中。

要获得进展，只需将AtomicInteger之类的线程安全对象传递给@Asynchronous方法，并让bean代码定期更新，并完成百分比。

答案 1 :(得分：43)

简介

在会话作用域托管bean中生成线程不一定是黑客，只要它能完成你想要的工作。但产生线程本身需要非常谨慎地完成。代码不应该以单个用户可以为每个会话产生无限量的线程和/或即使在会话被销毁之后线程继续运行的方式编写。它迟早会破坏你的申请。

代码需要以这样的方式编写，即您可以确保用户可以例如从不为每个会话生成多个后台线程，并且保证线程在会话被销毁时被中断。对于会话中的多个任务，您需要对任务进行排队。

此外，所有这些线程最好应由公共线程池提供，以便您可以在应用程序级别对生成的线程总量进行限制。普通的Java EE应用程序服务器提供了一个容器管理的线程池，您可以通过其中的EJB @Asynchronous和@Schedule来使用它。要与容器无关，您还可以使用Java 1.5的Util Concurrent ExecutorService和ScheduledExecutorService。

下面的示例假设Java EE 6+与EJB。

在表单提交时触发并忘记任务

@Named
@RequestScoped // Or @ViewScoped
public class Bean {

    @EJB
    private SomeService someService;

    public void submit() {
        someService.asyncTask();
        // ... (this code will immediately continue without waiting)
    }

}

@Stateless
public class SomeService {

    @Asynchronous
    public void asyncTask() {
        // ...
    }

}

在页面加载时异步获取模型

@Named
@RequestScoped // Or @ViewScoped
public class Bean {

    private Future<List<Entity>> asyncEntities;

    @EJB
    private EntityService entityService;

    @PostConstruct
    public void init() {
        asyncEntities = entityService.asyncList();
        // ... (this code will immediately continue without waiting)
    }

    public List<Entity> getEntities() {
        try {
            return asyncEntities.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new FacesException(e);
        } catch (ExecutionException e) {
            throw new FacesException(e);
        }
    }
}

@Stateless
public class EntityService {

    @PersistenceContext
    private EntityManager entityManager;

    @Asynchronous
    public Future<List<Entity>> asyncList() {
        List<Entity> entities = entityManager
            .createQuery("SELECT e FROM Entity e", Entity.class)
            .getResultList();
        return new AsyncResult<>(entities);
    }

}

如果您正在使用JSF实用程序库OmniFaces，如果使用@Eager注释托管bean，则可以更快地完成此操作。

在应用程序启动时安排后台作业

@Singleton
public class BackgroundJobManager {

    @Schedule(hour="0", minute="0", second="0", persistent=false)
    public void someDailyJob() {
        // ... (runs every start of day)
    }

    @Schedule(hour="*/1", minute="0", second="0", persistent=false)
    public void someHourlyJob() {
        // ... (runs every hour of day)
    }

    @Schedule(hour="*", minute="*/15", second="0", persistent=false)
    public void someQuarterlyJob() {
        // ... (runs every 15th minute of hour)
    }

    @Schedule(hour="*", minute="*", second="*/30", persistent=false)
    public void someHalfminutelyJob() {
        // ... (runs every 30th second of minute)
    }

}

在后台持续更新应用程序范围的模型

@Named
@RequestScoped // Or @ViewScoped
public class Bean {

    @EJB
    private SomeTop100Manager someTop100Manager;

    public List<Some> getSomeTop100() {
        return someTop100Manager.list();
    }

}

@Singleton
@ConcurrencyManagement(BEAN)
public class SomeTop100Manager {

    @PersistenceContext
    private EntityManager entityManager;

    private List<Some> top100;

    @PostConstruct
    @Schedule(hour="*", minute="*/1", second="0", persistent=false)
    public void load() {
        top100 = entityManager
            .createNamedQuery("Some.top100", Some.class)
            .getResultList();
    }

    public List<Some> list() {
        return top100;
    }

}

另见：

答案 2 :(得分：-4)

我试过这个并且从我的JSF托管bean

中运行得很好 
ExecutorService executor = Executors.newFixedThreadPool(1);

@EJB
private IMaterialSvc materialSvc;

private void updateMaterial(Material material, String status,  Location position) {

    executor.execute(new Runnable() {
        public void run() {
            synchronized (position) {
                // TODO update material in audit? do we need materials in audit?
                int index = position.getMaterials().indexOf(material);
                Material m = materialSvc.getById(material.getId());
                m.setStatus(status);
                m = materialSvc.update(m);
                if (index != -1) {
                    position.getMaterials().set(index, m);
                }

            }
        }
    });

}

@PreDestroy
public void destory() {
    executor.shutdown();
}
相关问题
最新问题