пул потоков Java продолжает работать

Question

Это более общий вопрос, чем конкретный.Я пытаюсь создать многопоточную среду, которая остается активной, чтобы я мог просто отправлять задачи и запускать их.Я хочу сделать это без хлопот выполнения на веб-сервере или сервере приложений.Идея заключалась в том, чтобы использовать для этого пул потоков Java, но проблема в том, что пул остается открытым только до завершения моего основного метода, после чего он, очевидно, закрывается и программа завершается.Как я могу предотвратить это?Я уверен, что есть несколько вариантов, некоторые из которых более наивны, чем другие (хотя на ум приходят истинные циклы).Есть идеи?Благодарю.

Answer 1

Как принимаются ваши задачи?

Во многих случаях я видел, что 1 поток ожидал или опрашивал задачи и передавал их.Этот поток будет поддерживать ваше приложение живым, а также может ждать, пока какой-либо знак завершит работу приложения, и дождаться завершения и очистки текущих заданий.

В общем, я нахожу точку, где возникают проблемыРабота с этими событиями жизненного цикла приложения не требует сложного развертывания в простой контейнер, такой как Jetty.Специально для работы в фоновом режиме я нахожу много полезного на нескольких глупых страницах JSP, чтобы убедиться, что он все еще работает (для интеграции с нашим автоматическим мониторингом) и получить некоторую статистику.

Answer 2

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());
    }
}

Answer 3

Вот код, который я вызываю в конце моей функции main () в некоторых программах.Если пользователь вводит «выход» в командной строке, программа очищается и завершает работу.Или вы можете изменить, где, если пользователь вводит «действие», чтобы сделать что-то еще.

   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 4

Вот пример, который я написал для другого поста, который позволяет вам передавать пул потоков в другой поток, в который вы можете публиковать сообщения.Функция main () создает потоки, а также позволяет вам остановить поток, когда вы захотите.Чтобы остановить основную от завершения, просто удалите процессор.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 5

Что вы определенно можете сделать, так это цикл примерно такой:

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
}