用一个java命令执行两个不同的类

是否可以用一个

java

命令执行两个单独的类

---

我想为我的项目同时运行几个java程序（它应该同时启动）

示例：我有两个java程序

A.java

和

B.java

编撰 跑 然而，这不起作用。我还能怎么做呢？

不，根本不是这样工作的

---

取而代之的是一个调用

a

和

B

类的

C.java

。

不，CPU总是像第一个一样启动一个命令，您可以做的是让两个线程等待一些通知，通知它们启动，但即使这样，我也会猜测它们中的一个会在另一个之前启动。

无论您如何努力同时启动它们，输出都不会一致。即使您尝试通过第三类加载它们，这也不会起作用

您可以做的是需要在代码中处理此逻辑。可能的选择是-

在单独的线程中运行对象，并使一个线程连接另一个线程。（这应该是理想的情况。两种方式的依赖性都不好）

在两个程序中添加逻辑，以便在同一给定时间执行关键代码（例如，使两个程序都在美国东部时间16:00运行）。（我还是会说#1个选项更好）

---

创建一个类，比如说

Parallel

，将其他类名作为命令行参数。 然后为每个类启动一个新线程并调用其主线程

也许可以做得更整洁些

java Parallel A B

public class Parallel {

    public static void main(String[] args) {
        for (String arg : args) {
            try {
                Class<?> klazz = Class.forName(arg);
                final Method mainMethod = klazz.getDeclaredMethod("main",
                    String[].class);
                if (mainMethod.getReturnType() != void.class) {
                    throw new NoSuchMethodException("main not returning void");
                }
                int modifiers = mainMethod.getModifiers();
                if (!Modifier.isStatic(modifiers)
                    || !Modifier.isPublic(modifiers)) {
                    throw new NoSuchMethodException("main not public static");
                }
                Thread thread = new Thread(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            mainMethod.invoke(null, (Object)new String[0]);
                        } catch (IllegalAccessException
                            | IllegalArgumentException
                            | InvocationTargetException ex) {
                            Logger.getLogger(Parallel.class.getName())
                                .log(Level.SEVERE, null, ex);
                        }
                    }
                });
                thread.start();
            } catch (ClassNotFoundException
                | NoSuchMethodException
                | SecurityException ex) {
                Logger.getLogger(Parallel.class.getName())
                    .log(Level.SEVERE, null, ex);
            }                        
        }
    }
}

java并行A/B
公共类并行{
公共静态void main（字符串[]args）{
for（字符串arg:args）{
试一试{
Class klazz=Class.forName（arg）；
final Method main Method=klazz.getDeclaredMethod（“main”，
字符串[]。类）；
if（mainMethod.getReturnType（）！=void.class）{
抛出新的NoSuchMethodException（“main不返回void”）；
}
int modifiers=main方法.getModifiers（）；
if（！Modifier.isStatic）（修饰符）
||！Modifier.isPublic（修饰符））{
抛出新的NoSuchMethodException（“主非公共静态”）；
}
Thread Thread=新线程（new Runnable（）{
@凌驾
公开募捐{
试一试{
调用（空，（对象）新字符串[0]）；
}捕获（非法访问）异常
|非法辩论例外
|调用目标异常（ex）{
Logger.getLogger（Parallel.class.getName（））
.log（Level.SEVERE，null，ex）；
}
}
});
thread.start（）；
}catch（ClassNotFoundException
|NoSuchMethodException
|安全例外（ex）{
Logger.getLogger（Parallel.class.getName（））
.log（Level.SEVERE，null，ex）；
}                        
}
}
}

是否使用两个不同的命令

javaa

，然后

javab

。或者创建

类C

，该类启动线程运行A，并立即启动线程运行B“它应该同时启动”。即使有办法，也不能保证并发执行。：谢谢你的代码。但是它不能正常工作。我在执行它时遇到以下错误。java.lang.IllegalArgumentException:参数数量错误。。。。。。在java.lang.reflect.Method.invoke（Method.java:601）的并行$1.run（Parallel.java:28）的java.lang.Thread.run（Thread.java:722）中，此行对应-->mainMethod.invoke（null）；在代码中，您是对的，静态调用为null（no

this

），但忘记了参数

String[]args

。

java A B

java Parallel A B

public class Parallel {

    public static void main(String[] args) {
        for (String arg : args) {
            try {
                Class<?> klazz = Class.forName(arg);
                final Method mainMethod = klazz.getDeclaredMethod("main",
                    String[].class);
                if (mainMethod.getReturnType() != void.class) {
                    throw new NoSuchMethodException("main not returning void");
                }
                int modifiers = mainMethod.getModifiers();
                if (!Modifier.isStatic(modifiers)
                    || !Modifier.isPublic(modifiers)) {
                    throw new NoSuchMethodException("main not public static");
                }
                Thread thread = new Thread(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            mainMethod.invoke(null, (Object)new String[0]);
                        } catch (IllegalAccessException
                            | IllegalArgumentException
                            | InvocationTargetException ex) {
                            Logger.getLogger(Parallel.class.getName())
                                .log(Level.SEVERE, null, ex);
                        }
                    }
                });
                thread.start();
            } catch (ClassNotFoundException
                | NoSuchMethodException
                | SecurityException ex) {
                Logger.getLogger(Parallel.class.getName())
                    .log(Level.SEVERE, null, ex);
            }                        
        }
    }
}