保持主要方法运行的最佳方法

Question

我使用了一种方法来保持 main 方法运行。

public static void main(String[] args) throws InterruptedException {
    while (true) {
        TimeUnit.SECONDS.sleep(1);
    }
}

但我不确定这是不是最好的方法。

谁能给我一些建议？

Answer 1

最好的方法是保持 main() 线程不进入 Terminated/Dead 状态。 以下是我经常使用的两种方法-

 public static void main(String[] args) throws InterruptedException {

    System.out.println("Stop me if you can");
   Thread.currentThread().join(); // keep the main running
  }

另一种方法是创建 ReentrantLock 并在其上调用 wait()：

public class Test{
private static Lock mainThreadLock = new ReentrantLock();

public static void main(String[] args) throws InterruptedException {

    System.out.println("Stop me if you can");
    synchronized (mainThreadLock) {
        mainThreadLock.wait();
     }
}

Answer 2

你有很多选择，其中一些：

• 简单线程
• 定时器任务
• ScheduledExecutorService

简单线程：

public class Task {
  public static void main(String[] args) {
      final long timeInterval = 1000;
      Runnable runnable = new Runnable() {
       public void run() {
          while (true) {
              System.out.println("Running Task ...");
                try {
                   Thread.sleep(timeInterval);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
          }
       }
      };
      Thread thread = new Thread(runnable);
      thread.start();
  }
 }

定时器任务：

 import java.util.Timer;
 import java.util.TimerTask;
 public class Task {
     public static void main(String[] args) {
          TimerTask task = new TimerTask() {
               @Override
               public void run() {
                   System.out.println("Running Task ...");
               }
          };
          Timer timer = new Timer();
          long delay = 0;
          long intevalPeriod = 1000; 
          timer.scheduleAtFixedRate(task, delay,intevalPeriod);
      } 
 }

ScheduledExecutorService：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Task {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
             public void run() {
               System.out.println("Running Task ...");
             }
        };
    ScheduledExecutorService service = Executors
                .newSingleThreadScheduledExecutor();
    service.scheduleAtFixedRate(runnable, 0, 1, TimeUnit.SECONDS);
    }
 }

Answer 3

您应该使用 ExecutorService 并提交一个等待读取服务输出的任务。

package demo;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class TaskDemo {
    public static void main(String[] args ) {
        System.out.println("Hello");

        ExecutorService threadPool = Executors.newFixedThreadPool(1);

        Runnable task = () -> {
            try {
                //Loop to read your services's output
                Thread.sleep(1000);
                System.out.println("This is from Task");
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        };
        threadPool.execute(task);
        //Wait for the task to finish and shutdow the pool
        threadPool.shutdown();
    }
}

Answer 4

这是一种维护主要 java 实例运行直到您想要退出的方法。使用 GUI 来做到这一点：

public static void main(String[] args){
    JFrame jFrame = new JFrame();
    jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    jFrame.setLocationRelativeTo(null);
    jFrame.setSize(480, 260);
    jFrame.setVisible(true);
    //do some task here
}