如何为Java并发应用程序创建一个优化的场景？

我一直在寻找类似的问题，但对于我的要求，我认为我需要一些特殊的东西，我会详细解释

首先，我需要迁移一个以前以这种方式工作的系统：

名为ServerPool（Thread）的类使用主类初始化

此服务器池创建用于接收套接字的队列和用于管理工作线程的向量

因此，在池的代码中，我有以下内容：

public class ServerPool extends Thread {
    private LinkedBlockingQueue<SearchQuery> workQueue; //SearchQuery is a Class I defined which can handle two type of processes (for sockets and for single Strings)
    private Vector<SearchThread> workers;
    private final int NTHREADS = 10;
    private int typeOfQuery;

    public ServerPool() {
    workers = new Vector<SearchThread>(NUM_THREAD);
    workQueue = new LinkedBlockingQueue<SearchQuery>();
    this.typeOfQuery = typeOfQuery;
    SearchThread search = new SearchThread(workQueue);
    search.start();
    workers.add(search);
}

public void run() {
    while(true){
    SearchQuery client = null;

    if (typeOfQuery == 1) {
        client = new SocketQuery(....);
        } else if (typeOfQuery == 2) {
        client = new StringQuery(...);
        }
        workQueue.put(client);
}
}

公共类服务器池扩展线程{
private LinkedBlockingQueue workQueue；//SearchQuery是我定义的一个类，它可以处理两种类型的进程（套接字和单个字符串）
私人媒介工作者；
私人最终int NTHREADS=10；
私有int查询；
公共服务器池（）{
workers=新向量（NUM_线程）；
workQueue=新建LinkedBlockingQueue（）；
this.typeOfQuery=typeOfQuery；
SearchThread search=新的SearchThread（工作队列）；
search.start（）；
添加（搜索）；
}
公开募捐{
while（true）{
SearchQuery客户端=null；
if（typeOfQuery==1）{
客户端=新的SocketQuery（…）；
}else if（typeOfQuery==2）{
client=newstringquery（…）；
}
workQueue.put（客户端）；
}
}

对于执行进程的SearchThread：

public class SearchThread extends Thread {
    private LinkedBlockingQueue<SearchQuery> workQueue = null;
    private SearchQuery request = null;

    public SearchThread(LinkedBlockingQueue<SearchQuery> workSource) {
        workQueue = workSource;
    }   

    public void run() {
        request = workQueue.take();
        //Here I process the request
        //And use a PrintWriter to give a "response"            
    }

}

公共类SearchThread扩展线程{
private LinkedBlockingQueue workQueue=null；
私有搜索查询请求=null；
公共搜索线程（LinkedBlockingQueue工作源）{
工作队列=工作源；
}   
公开募捐{
request=workQueue.take（）；
//我在这里处理请求
//并使用打印机给出“响应”
}
}

以前使用telnet和套接字可以实现这一点，但现在我被要求将其转换为Web服务，因此作为Web服务，它应该返回一个值，因此我考虑使用可调用池、未来池和线程池，但我无法完全复制相同的行为，我尝试实现了这一点：

public class NewServerPool {

    private final int NTHREADS = 10;
    private ExecutorService executor;
    private LinkedBlockingQueue<SearchQuery> workQueue;
    private Vector<Future<String>> futures;
    private boolean end = true;

    public NewServerPool(int port, SearchQuery typeOfQuery) {
        executor = Executors.newFixedThreadPool(NTHREADS);
        workQueue = new LinkedBlockingQueue<SearchQuery>();
        futures = new Vector<Future<String>>();

    }


}

公共类新闻服务器池{
私人最终int NTHREADS=10；
私人遗嘱执行人；
私有LinkedBlockingQueue工作队列；
私人媒介期货；
私有布尔结束=true；
公共新闻服务器池（int端口，SearchQuery-typeOfQuery）{
executor=Executors.newFixedThreadPool（NTHREADS）；
workQueue=新建LinkedBlockingQueue（）；
期货=新向量（）；
}
}

对于搜索线程来说，现在它是可调用的

public class NewSearchThread implements Callable<String>{

    private SearchQuery searchQuery;

    public NewSearchThread(SearchQuery searchQuery) {
        this.searchQuery = searchQuery;
    }

    @Override
    public String call() throws Exception {
        String xmlResponse = null;

        if (searchQuery == null) {
            throw new InvalidSearchQueryException("The search query is not valid or has null value: " + searchQuery);
        }

        if (searchQuery instanceof SocketTimed) {
            System.out.println("It is socket timed query type");
        } else if (searchQuery instanceof WebServiceQuery) {
            System.out.println("It is a web service query type");
        }

        xmlResponse = searchQuery.manageResponse();

        return xmlResponse;
    }

公共类NewSearchThread实现可调用{
私有搜索查询；
公共新闻搜索线程（SearchQuery）{
this.searchQuery=searchQuery；
}
@凌驾
公共字符串调用（）引发异常{
字符串xmlResponse=null；
if（searchQuery==null）{
抛出新的InvalidSearchQueryException（“搜索查询无效或具有空值：“+searchQuery”）；
}
if（SocketTimed的searchQuery实例）{
System.out.println（“它是套接字定时查询类型”）；
}else if（WebServiceQuery的searchQuery实例）{
System.out.println（“这是一种web服务查询类型”）；
}
xmlResponse=searchQuery.manageResponse（）；
返回XML响应；
}

所以我在服务器池中遇到了麻烦，我的Web服务将调用一个新的服务器池实例（NewServerPool）。在这种情况下，我如何继续？如果有人能帮助我，我将非常感激。 提前感谢，致以最诚挚的问候。

有几件事：

首先，您原来的

ServerPool

类有缺陷，因为它只实例化了

SearchThread

的一个实例。我想您的意思是启动

NTHREADS

（10）

SearchThread

s

接下来，您似乎稍微改变了

NewSearchThread

的方法，即

NewSearchThread

的构造函数使用

SearchQuery

参数，而

SearchThread

从

阻塞队列中使用
SearchQuery

最后，您的
NewServerPool
类的方法不同于
ServerPool
，因为
ServerPool
的
run（）
方法不断地将新的
SearchQuery
放入
BlockingQueue
中。相比之下，
NewServerPool
的构造函数只使用一个
SearchQuery
而不使用它

用这样的方法开始吧：

public class NewServerPool extends Thread {

    private final int NTHREADS = 10;
    private ExecutorService executor;
    private Vector<Future<String>> futures;

    public NewServerPool(int port, SearchQuery typeOfQuery) {
        executor = Executors.newFixedThreadPool(NTHREADS);
        futures = new Vector<Future<String>>();
    }

    public void run() {
        while(true){
            SearchQuery client = null;

            if (typeOfQuery == 1) {
                client = new SocketQuery(....);
            } else if (typeOfQuery == 2) {
                client = new StringQuery(...);
            }
            futures.add(executor.submit(new NewSearchThread(client)));
        }
    }
}

公共类NewServerPool扩展线程{
私人最终int NTHREADS=10；
私人遗嘱执行人；
私人媒介期货；
公共新闻服务器池（int端口，SearchQuery-typeOfQuery）{
executor=Executors.newFixedThreadPool（NTHREADS）；
期货=新向量（）；
}
公开募捐{
while（true）{
SearchQuery客户端=null；
if（typeOfQuery==1）{
客户端=新的SocketQuery（…）；
}else if（typeOfQuery==2）{
client=newstringquery（…）；
}
futures.add（executor.submit（NewSearchThread（client））；
}
}
}

请注意，我说的是“让您开始”…因为上面仍然需要一些附加内容，例如在停止处理请求时正确退出
run（）
方法（但这是另一个主题）。
有几件事：

首先，您原来的
ServerPool
类有缺陷，因为它只实例化了
SearchThread
的一个实例。我想您的意思是启动
NTHREADS
（10）
SearchThread
s

接下来，您似乎稍微改变了
NewSearchThread
的方法，而不是
SearchThread
——因为
NewSearchThread的构造函数
public class NewServerPool {

    private final int NTHREADS = 10;
    private ExecutorService executor;
    private Vector<Future<String>> futures;

    public NewServerPool(int port, SearchQuery typeOfQuery) {
        futures = new Vector<Future<String>>();
    }

    public boolean launchThreadPool() {
        executor = Executors.newFixedThreadPool(NTHREADS);
        return true;
    }

    public void submitToThreadPoolForProcessing(SearchQuery client) {
        futures.add(executor.submit(new NewSearchThread(client)));
    }

    public Vector<Future<String>> getFutures() {
        return futures;
    }
}