3

假设我有一堂课：

public class MyTask implements Runnable {
    @Inject
    private Fizz fizz;

    // Getters and setters for 'fizz'.

    @Override
    public void run() {
        if(fizz.alleviatesBuzz())
            doA();
        else
            doB();
    }

    private void doA() { ... }

    private void doB() { ... }
}

然后我有另一堂课：

public class MyTaskDispatcher {
    @Inject
    private ThreadFactory threadFactory;

    private Executor executor;

    // Getter and setter for 'threadFactory'.

    public void dispatch(MyTask task) {
        if(executor == null)
            executor = Executors.newCachedThreadPool(threadFactory);

        executor.submit(task);
    }
}

所以 Guice 注入MyTask了 a Fizz，也注入MyTaskDispatcher了 aThreadFactory然后用于创建和执行MyTask它传递的实例。而且，由于它是一个缓存池，它只在需要但不可用时创建一个新线程。

我想知道当我们Fizz作为单例或非单例注入时，Guice 在多线程环境中的“行为”如何。

让我们从非单例实例开始：

public class MyAppModule extends AbstractModule {
    @Override
    public void configure() {
        bind(Fizz.class).to(FizzImpl.class);

        // I don't think the functionality of MyThreadFactory
        // really matters for the sake of this question.
        bind(ThreadFactory.class).to(MyThreadFactory.class);
    }

    @Provides
    FizzImpl providesFizz() {
        return new FizzImpl(true, Buzz.ALWAYS, 35);
    }

    // I *believe* we always want the ThreadFactory to be singleton,
    // because all of the threads spawn from it and its executor.
    @Provides @Singleton
    ThreadFactory providesThreadFactory() {
        return new MyThreadFactory(12);
    }
}

现在假设应用程序已经运行了一段时间，并且MyTask已经提交了3个单独的s，因此存在3个运行线程。由于我们没有要求 Guice 将Fizzes 作为单例注入，因此我假设每个线程都有自己的注入副本FizzImpl，并且我们不必添加任何synchronize-type 代码来防止 3 FizzImpls 碰撞并导致线程问题。

但是当我们让 GuiceFizzImpl作为单例注入时会发生什么？！？现在，在MyAppModule：

    @Provides @Singleton
    FizzImpl providesFizz() {
        return new FizzImpl(true, Buzz.ALWAYS, 35);
    }

如果 Guice 只提供 1 个全局的单例实例，那么在 3 个衍生线程中的每个线程中，该“副本”（如果这是正确的词的话）FizzImpl的下游分支是什么？FizzImpl有哪些陷阱需要注意？有什么方法可以对抗这些陷阱？提前致谢。

4

1 回答 1

1

不，Fizz 将使用 MyTask 实例创建，并且它将在多个线程调用中持续存在。如果你想为每个线程创建一个 Fizz 副本，你必须以懒惰的方式进行。

public class MyTask implements Runnable {
    @Inject
    private Provider<Fizz> fizzProvider;

    // Getters and setters for 'fizz'.

    @Override
    public void run() {
        Fizz fizz = fizzProvider.get();
        if(fizz.alleviatesBuzz())
            doA();
        else
            doB();
    }

    private void doA() { ... }

    private void doB() { ... }
}

但是，如果您将 Singleton 标志放入 Fizz 绑定，则在您调用 fizzProvider.get() 时提供程序将返回相同的实例，因此所有线程将具有相同的实例。你必须保持它不是单例的。

另外你的模块是错误的，你应该使用方法或隐式绑定，而不是两者。你也不能提供实例并注入它的接口。

public class MyAppModule extends AbstractModule {
    @Override
    public void configure() {
        bind(Fizz.class).to(FizzImpl.class);
        //or bind(Fizz.class).toInstance(new FizzImpl(true, Buzz.ALWAYS, 35)); //Singleton!!
        //or bind(Fizz.class).toProvider(new Provider<Fizz>() {
        //      @Override
        //      public Subject get() {
        //        return new FizzImpl(true, Buzz.ALWAYS, 35);
        //      }
        //    });

        // I don't think the functionality of MyThreadFactory
        // really matters for the sake of this question.
        bind(ThreadFactory.class).to(MyThreadFactory.class);
    }
}

或者

public class MyAppModule extends AbstractModule {
    @Override
    public void configure() {
    }

    @Provides
    Fizz providesFizz() {
        return new FizzImpl(true, Buzz.ALWAYS, 35);
    }

    // I *believe* we always want the ThreadFactory to be singleton,
    // because all of the threads spawn from it and its executor.
    @Provides @Singleton
    ThreadFactory providesThreadFactory() {
        return new MyThreadFactory(12);
    }
}

希望它会有所帮助！

于 2013-07-26T11:56:09.883 回答