2

在我的客户端/服务器桌面应用程序上。我有这个问题，我应该如何使用我的模型正确编码我的 JDBC 类，以确保所有持久性请求都可以支持并发。i.e., multiple models want to request update to its persistence counterpart simultaneously [without atmost delay].

情节是这样的。遵循位于服务器应用程序中的类。

持久性包：

abstract class AbstractService {
  // other fields
  private final String tName, tId;
  private final String sqlStatement;
  public AbstractService(final String tName, final String tId) {
    this.tName = tName;
    this.tId = tId;
    this.sqlStatement = ""; // SELECT statement
  }
  // java.sql.Connection() createConnection()
  // methods
}
public class T1Service extends AbstractService {
  private final String sqlDMLStatements;
  public T1Service() {
    super("t1", "t1Id");
    this.sqlDMLStatements = ""; // other DML statements
  }      
  // methods having return types of List<E>, Object, Boolean, etc.
  // i.e., public List<E> listAll()
}

通讯类【客户端类】

import java.net.*;
import java.io.*;
public class Client extends Observable{
  private Socket socket;
  private ObjectInputStream input;
  private ObjectOutputStream output;
  private Object message;
  // Constructor
  // Getters/Setters
  // Other methods like open or close input/output
  private class ReceiverRunnable implements Runnable
    @Override
    public void run() {
       while(running) { // if socket is still open and I/O stream are open/initialized
          try { message = input.readObject(); } 
          catch(Exception e) {}
          finally { setChanged(); notifyObservers(); }  
       } 
    }
  }
}

主类【服务器类】

import java.net.*;
public class Server {
   private List<Client> clientList; // holds all active connections with the server
   private T1Service    t1Service
   private class ConnectionRunnable implements Runnable {
      @Override public void run() {
         while(running) { // serverSocket is open
           Client client = new Client(ServerSocket.accept(), /* other parameters */);
           client.addObserver(new ClientObserver(client));
           clientList.add(client);
         }
      } 
   }
   private class ClientObserver implements Observer {
      private Client client;
      // Constructor
      public void update(Observable o, Object arg) {
         // Check the contents of 'message' to determine what to reply
         // i.e., message.equals("Broadcast") {
         // synchronized(clientList) {
         //   for(Client element : clientList) {
         //     element.getOutput().writeObject(replyObject);
         //     element.getOutput()..flush();
         //   }
         // }
         // i.e., message.equals("T1") {
         // synchronized(t1Service) {
         //     client.getOutput().writeObject(t1.findAll());
         //     client.getOutput().flush();
         // }
      } 
   } 
}

由于这是一个客户端/服务器应用程序，来自客户端的多个请求同时馈送到服务器。服务器处理请求，将适当的回复发送给适当的客户端。注意：客户端和服务器之间发送的所有对象都是 java.io.Serializable 的实例。

遇到这种情况并调查Server.ClientServer.update()我们可能会遇到性能问题，或者我应该说由于Intrinsic Locks. 但是由于我必须遵守规则concurrency并synchronization确保Server.T1Service不会对 N 个客户端请求的队列感到困惑。以下是问题：

  1. 根据Effective Java - Second Edition的第 1 项Static Factory，这是否可以让我创建一个新的类引用来引用 Persistence 包的类中的方法？
  2. 内部的每个Client元素List<Client>是否会形成一个并发问题，让 N 个客户端message同时更新其字段，从而触发ClientObsver.update()其中此观察者的引用对象只是父类中的单个实例。由于内存问题，我避免创建 T1Service 的多个实例。
  3. 如果我们要通过 Effective Java - Second Edition 的内容，我怎样才能将我的持久性类转换为易于阅读、易于实例化并支持并发的方式？
4

2 回答 2

2

您可能还想查看 Actors，例如Akka中的 Actors

演员的基本思想是完全避免同步，使用发送事件。Akka 将保证一个actor永远不会被两个线程并行调用。所以你可以定义actor，它对全局变量做一些事情，然后简单地向它发送消息。

通常像魅力一样工作:)

于 2012-09-05T19:17:24.917 回答
1

我的 [Item 1] 静态工厂理论正确吗？

是的，您可以使用静态工厂而不是构造函数。通常这是当您的构造逻辑很复杂并且在各种子类型之间共享以保证工厂模式时。此外，工厂可以在 DI 框架之外提供依赖注入的方法。

那么它会解决转换后的静态工厂全局对象的并发问题吗？

如果您需要同步构造，那么静态工厂效果很好，只需synchronized在工厂方法的方法声明中添加即可。如果您需要同步对象本身的方法，那么这将无济于事。

如果在哪里处理对全局对象的并发访问以及在哪里需要实时访问每个全局对象的方法，我是否建议转换为静态工厂？

正如我上面回答的那样，这取决于您要达到的目标。对于构造函数同步，使用工厂。

于 2012-09-05T19:29:48.240 回答