Java 如何使应用程序构建块线程安全？
我有很多遗留代码，这些代码在很大程度上由具有以下结构的类组成：Java 如何使应用程序构建块线程安全？,java,multithreading,thread-safety,Java,Multithreading,Thread Safety,我有很多遗留代码，这些代码在很大程度上由具有以下结构的类组成： public interface MyFunctionalBlock { // Setters for the inputs void setInput1(final int aInput1); void setInput2(final Object aInput2); // Inside the method run inputs are converted into results vo
public interface MyFunctionalBlock
{
// Setters for the inputs
void setInput1(final int aInput1);
void setInput2(final Object aInput2);
// Inside the method run inputs are converted into results
void run();
// If this building block needs functionality from some other building blocks,
// it gets a reference to them from the Google Guice injector.
void setInjector(final Injector aInjector);
// Getters for the results
long getResult1();
Object getResult2();
Map<String,String> getResult3();
}
public class MyFunctionalBlockFactory implements Factory<MyFunctionalBlock>
{
public MyFunctionalBlock create()
{
return new DefaultMyFunctionalBlock();
}
}
class DefaultMyFunctionalBlock implements MyFunctionalBlock
{
private int input1;
private Object input2;
private long result1;
private long result2;
private Map<String,String> result3;
private Injector injector;
@Override
public void run()
{
// Here the calculations are performed.
// If this functional block needs another one, it gets a reference to it using the injector.
// AnotherFunctionalBlock is the public interface. Implementations of the interface are
// intentionally hidden using injector and package-private declaration.
final AnotherFunctionalBlock fb = injector.getInstance(AnotherFunctionalBlock.class);
// First, we set the inputs
fb.setInput1(...);
fb.setInput2(...);
[...]
fb.setInputN(...);
// Now we run the calculation
fb.run();
// Now we can use the results
fb.getResult1();
fb.getResult2();
[...]
fb.getResultN();
}
// Implementation of getters and setters omitted
}
public class WebService1
{
private Backend backend;
public Response processRequest(SomeRequest1 request)
{
return wrapResultIntoResponse(backend.doSomeThreadUnsafeStuff1(request.getParameter1(), request.getParameter2()));
}
}
public class WebService2
{
private Backend backend;
public Response processRequest(SomeRequest2 request)
{
return wrapResultIntoResponse(backend.doSomeThreadUnsafeStuff2(request.getParameter1(), request.getParameter2(), request.getParameter3()));
}
}
后端后端final AnotherFunctionalBlock fb = injector.getInstance(AnotherFunctionalBlock.class);
synchronized(fb)
{
fb.setInput1(...);
fb.setInput2(...);
[...]
fb.setInputN(...);
fb.run();
fb.getResult1();
fb.getResult2();
[...]
fb.getResultN();
}
public class Backend
{
private synchronized boolean busy = false;
public Object doSomeThreadUnsafeStuff1(Long aParameter1, String aParameter2)
{
waitUntilIdle();
synchronized (this)
{
busy=true;
// Here comes the non-thread safe stuff 1
busy=false;
notifyAll();
}
}
public Object doSomeThreadUnsafeStuff2(Long aParameter1, String aParameter2, Map<String,String> aParameter3)
{
waitUntilIdle();
synchronized (this)
{
busy=true;
// Here comes the non-thread safe stuff 2
busy=false;
notifyAll();
}
}
private void waitUntilIdle()
{
while (busy)
{
wait();
}
}
}
公共类后端
{
私有同步布尔忙=假；
公共对象doSomeThreadUnsafeStuff1（长APParameter1，字符串APParameter2）
{
waitUntilIdle（）；
已同步（此）
{
忙=真；
//下面是非线程安全的东西1
忙=假；
notifyAll（）；
}
}
公共对象doSomeThreadUnsafeStuff2（长APParameter1，字符串APParameter2，映射APParameter3）
{
waitUntilIdle（）；
已同步（此）
{
忙=真；
//下面是非线程安全的东西2
忙=假；
notifyAll（）；
}
}
私有void waitUntilIdle（）
{
当（忙）
{
等待（）；
}
}
}
这个解决方案行得通吗？除了“使其多线程化”之外，还不清楚您想要实现什么。Java中的并发性是一个非常复杂的主题，对于如何将整个应用程序从单线程转换为多线程，您不会找到一个单一的、逐步的答案。如果你这样做，我会完全不相信这个答案。我建议你拿起，这类事情的事实参考。这就是解决这个问题所需要了解的内容。除了“使其多线程化”之外，还不清楚您想要实现什么。Java中的并发性是一个非常复杂的主题，对于如何将整个应用程序从单线程转换为多线程，您不会找到一个单一的、逐步的答案。如果你这样做，我会完全不相信这个答案。我建议你拿起，这类事情的事实参考。这就是如何了解解决此问题所需的知识。您在更新2中提出的解决方案将使整个应用程序线程安全。我将其总结为在web用户和实际业务代码之间放置一个facade/singleton层。遗留代码本身不是线程安全的，因此您必须重写它，但是由于您完全控制对它的访问并以单线程方式执行它，所以总体上是可以的。如果对底层业务代码有任何不受控制的访问，它显然会失败
你说“目前，我不在乎表现”。我希望你是对的，因为就锁争用而言，这是一个可怕的想法。但是，如果您所要做的只是将这个不安全的代码作为web服务公开，而不提供简单的访问，那么是的，将同步的单例外观放在顶部将起作用。您在更新2中提出的解决方案将使整个应用程序线程安全。我将其总结为在web用户和实际业务代码之间放置一个facade/singleton层。遗留代码本身不是线程安全的，因此您必须重写它，但是由于您完全控制对它的访问并以单线程方式执行它，所以总体上是可以的。如果对底层业务代码有任何不受控制的访问，它显然会失败 你说“目前，我不在乎表现”。我希望你是对的，因为就锁争用而言，这是一个可怕的想法。但是，如果您所要做的只是将这些不安全的代码作为web服务公开，而不提供简单的访问，那么是的，将同步的单例外观放在顶部将起作用。您在“更新2”中描述的内容与。如果您100%确信自己对性能一点也不关心——我的意思是潜在的非常糟糕的性能——并且永远不会，那么您所建议的是一个公平的解决方案，尽管您建议的实现在
忙等待（）