java线程池保持运行

Question

这更像是一个一般性问题，而不是一个具体问题。我试图拥有一个保持活动状态的多线程环境，以便我可以提交任务并运行它们。我希望能够避免在 Web 服务器或应用程序服务器中执行的麻烦。我们的想法是为此使用 java 线程池，但这里的问题是池一直保持打开状态，直到我的 main 方法完成，之后显然它会关闭并且程序完成。我怎样才能防止这种情况发生？我确信有几种选择，其中一些比其他更天真（虽然我想到了真正的循环）。 有什么想法吗？谢谢。

Answer 1

您的任务如何被接受？

在许多情况下，我看到有 1 个线程正在等待或轮询任务并将其传递。该线程将使您的应用程序保持活动状态，还可以等待某些标志来关闭应用程序，并等待当前作业完成并清理。

总而言之，我发现处理这些应用程序生命周期事件的麻烦程度超过了部署到像 Jetty 这样的简单容器的麻烦程度。特别是对于在后台运行的东西，我在几个愚蠢的 JSP 页面中发现了很多价值，可以验证它是否仍在工作（与我们的自动监控集成）并获取一些统计数据。

Answer 2

这是我在某些程序中的 main() 末尾调用的一些代码。如果用户在命令行上键入“quit”，则程序将进行清理，然后退出。或者，您可以修改用户输入“操作”以执行其他操作的位置。

   public void serve() throws IOException
   {
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
      String line = null;

      for (;;)
      {
         out.print("> ");
         out.flush();
         line = in.readLine();
         if (line == null)
         {
            break;                  // QUIT if we get EOF
         }

         try
         {
            // Use a stringTokenizer to parse the user's command
            StringTokenizer t = new StringTokenizer(line);

            // blank line
            if (!t.hasMoreTokens())
            {
               continue;
            }

            // get the first word of the input and convert to lower case
            String command = t.nextToken().toLowerCase();

            if (command.equals("quit"))
            {
               bTerminate = true;
               // Do all cleanup here
               myClient.close();
               break;
            }
            else if (command.equals("action"))
            {
               if (line.length() > command.length())
               {
                  // get data from rest of line
                  String data = line.substring(command.length()).trim();
                  // perform action
                  myOutputStream.writeUTF(data);
               }
            }
         }
         catch(Exception e)
         {
            e.printStackTrace();
         }
      }
      out.close();
      in.close();
   }

Answer 3

这是我为另一篇文章编写的示例，它允许您在可以向其发布消息的另一个线程上提供线程池。 main() 创建线程，还允许您在需要时停止线程。要阻止 main 完成，只需消除processor.stopProcessing();主线。

package com.rch.test;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Executor
{
    /**
     * Class to encapsulate a request
     * 
     * @author romain
     */
    static class Request
    {
        String someText;

        Request(String someText)
        {
            this.someText = someText;
        }

        public String getSomeText()
        {
            return someText;
        }
    }

    /**
     * Creates a Thread that listens on a queue to process messages
     * 
     * @author romain
     */
    static class ServerThread implements Runnable
    {
        private BlockingQueue<Request> queue = new LinkedBlockingQueue<Request>();
        volatile boolean stop = false;

        /**
         * Does all the work
         */
        @Override
        public void run()
        {
            ExecutorService pool = Executors.newFixedThreadPool(3);
            try
            {
                while (!stop)
                {
                    Request req = queue.poll(1000L, TimeUnit.MILLISECONDS);
                    if (req != null)
                    {
                        Runnable runnable = new Executor.ImageProcessor(req);
                        pool.execute(runnable);
                    }
                }
            }
            catch (InterruptedException ie)
            {
                System.out.println("Log something here");
            }
            finally
            {
                pool.shutdown();
            }
        }

        /**
         * Accepts a message on the queue
         * @param request
         */
        public void accept(Request request)
        {
            queue.add(request);
        }

        public void stopProcessing()
        {
            stop = true;
        }
    }

    /**
     * class to do the actual work
     * @author romain
     */
    static class ImageProcessor implements Runnable
    {
        String someText;

        ImageProcessor(Request req)
        {
            this.someText = req.getSomeText();
        }

        @Override
        public void run()
        {
            System.out.println(someText);
            // Process Image here
        }
    }

    /**
     * Test Harness
     * @param args
     */
    public static void main(String[] args)
    {
        // Initialize 
        ServerThread processor = new ServerThread();
        Thread aThread = new Thread(processor);
        aThread.start();

        // Wait for Thread to start
        try
        {
            Thread.sleep(500L);
        }
        catch (InterruptedException e1)
        {
            e1.printStackTrace();
        }

        for (int i = 0; i < 100; i++)
        {
            String text = "" + i;
            Request aRequest = new Request(text);
            processor.accept(aRequest);
        }

        // Give it enough time to finish
        try
        {
            Thread.sleep(500L);
        }
        catch (InterruptedException e1)
        {
            e1.printStackTrace();
        }

        // Tell the thread to finish processing
        processor.stopProcessing();

        // Wait for the Thread to complete
        try
        {
            aThread.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

Answer 4

你绝对可以做的是一个像这样的循环：

while (true) {
  Thread.sleep(1000);
}

如果你不想停止这个进程，你就杀死它。然而，这并不是一个优雅的解决方案。

更好的是，监听某个端口并等待，直到您在该端口上收到一些命令：

ServerSocket socket = new ServerSocket(4444);
while (true) {
  Socket clientSocket = socket.accept();
  // get input stream, etc.
  // if(STOP keywoard read) break
}

Answer 5

public class Test extends Thread {

    private static Test thread1, thread2, thread3; //static added since tested from main()

    public static void main(String... arguments){
    try{    
        thread1 = new Test();
        thread2 = new Test();
        thread3 = new Test();
        // Add Names
        thread1.setName("A");
        // Add Sleep
        thread2.sleep(2000); //in milisecs - here it is 2sec
        // Add priority
        thread3.setPriority(Thread.MAX_PRIORITY);

        // Infinite loop
        while(true){    
            thread1.start();
            thread2.start();
            thread3.start();    
        }
    }catch(Throwable t){
        System.err.println(t.getMessage());
    }
}

    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}