Java 程序输出完成后返回命令行

编写了一个多线程程序，按顺序打印奇数和偶数，直到顺序达到30

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class NumPrintTX
{
public static void main(String[] args)
{
    final int max = 31;
    final AtomicInteger i = new AtomicInteger(0);
    Executor dd = Executors.newFixedThreadPool(2);

    final Object lock = new Object();

    dd.execute(new Runnable()
    {
        @Override
        public void run()
        {
            while (i.get() < max)
            {
                if (i.get() % 2 == 0)
                {
                    System.out.print(" " + i.getAndAdd(1));

                    synchronized(lock)
                    {
                        lock.notify();
                    }
                }
                else
                {
                    synchronized(lock)
                    {
                        try
                        {
                            lock.wait();
                        }
                        catch (InterruptedException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    });
    dd.execute(new Runnable()
    {
        @Override
        public void run()
        {
            while (i.get() < max)
            {
                if (i.get() % 2 != 0)
                {
                    System.out.print(" " + i.getAndAdd(1));

                    synchronized(lock)
                    {
                        lock.notify();
                    }
                }
                else
                {
                    synchronized(lock)
                    {
                        try
                        {
                            lock.wait();
                        }
                        catch (InterruptedException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    });
    do
    {
        try 
        {
            Thread.currentThread().sleep(1000);
            }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    while (i.get() != max);
}
}

import java.util.concurrent.Executor；
导入java.util.concurrent.Executors；
导入java.util.concurrent.AtomicInteger；
公共类NumPrintTX
{
公共静态void main（字符串[]args）
{
最终int最大值=31；
最终原子整数i=新的原子整数（0）；
Executor dd=Executors.newFixedThreadPool（2）；
最终对象锁=新对象（）；
dd.execute（新的Runnable（）
{
@凌驾
公开募捐
{
而（i.get（）

当程序运行时，结果很好，但它不会转到下一行，因此我可以为下一步要执行的任何操作输入另一个命令。你知道这是为什么吗？我能做些什么来修复它

修改代码： 导入java.util.concurrent.Executor； 导入java.util.concurrent.Executors； 导入java.util.concurrent.AtomicInteger

public class NumPrintTX
{
public static void main(String[] args)
{
    final int max = 31;
    final AtomicInteger i = new AtomicInteger(0);
    Executor dd = Executors.newFixedThreadPool(2);

    final Object lock = new Object();

    dd.execute(new Runnable()
    {
        @Override
        public void run()
        {
            while (i.get() < max)
            {
                if (i.get() % 2 == 0)
                {
                    System.out.print(" " + i.getAndAdd(1));

                    synchronized(lock)
                    {
                        lock.notify();
                    }
                }
                else
                {
                    synchronized(lock)
                    {
                        try
                        {
                            lock.wait();
                        }
                        catch (InterruptedException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    });
    dd.execute(new Runnable()
    {
        @Override
        public void run()
        {
            while (i.get() < max)
            {
                if (i.get() % 2 != 0)
                {
                    System.out.print(" " + i.getAndAdd(1));

                    synchronized(lock)
                    {
                        lock.notify();
                    }
                }
                else
                {
                    synchronized(lock)
                    {
                        try
                        {
                            lock.wait();
                        }
                        catch (InterruptedException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    });
    do
    {
        try 
        {
            Thread.currentThread().sleep(1000);
            }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    while (i.get() != max);
}
public void close()
{
System.exit(0);
}
}

公共类NumPrintTX
{
公共静态void main（字符串[]args）
{
最终int最大值=31；
最终原子整数i=新的原子整数（0）；
Executor dd=Executors.newFixedThreadPool（2）；
最终对象锁=新对象（）；
dd.execute（新的Runnable（）
{
@凌驾
公开募捐
{
而（i.get（）

您需要调用

系统退出程序。退出（0）其中
0
是“正常”退出的退出状态代码。应该在打印出数字的循环完成后进行调用

您没有停止线程池，因此它不会让主程序结束

考虑以下代码：

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

class Worker implements Runnable {
    private AtomicInteger i;
    private Object lock;
    private int max;
    private int mod;

    Worker(AtomicInteger i_, Object lock_, int max_, int mod_){ 
        this.i   = i_;
        this.lock = lock_;
        this.max  = max_;
        this.mod  = mod_; 
    }

    @Override
    public void run(){
        while (i.get() < max)
        {
            if(i.get() % 2 == mod)
            {
                System.out.print(" " + i.getAndAdd(1));

                synchronized(lock){ lock.notify(); }
            }
            else
            {
                synchronized(lock)
                {
                    try { lock.wait(); }
                    catch (InterruptedException e) { e.printStackTrace(); }
                }
            }
        }
    }
}

public class NumPrintTX
{
   public static void main(String[] args)
    {
        final int max = 31;
        final AtomicInteger i = new AtomicInteger(0);
        ExecutorService dd = Executors.newFixedThreadPool(2);

        final Object lock = new Object();

        dd.execute(new Worker(i, lock, max, 0));
        dd.execute(new Worker(i, lock, max, 1));

        dd.shutdown();
    }    
}

导入java.util.concurrent.Executors；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.AtomicInteger；
类工作者实现可运行的{
私有原子i；
私有对象锁；
私人int max；
私有int mod；
辅助程序（原子整数i、对象锁、int max、int mod）{
这个；
这是锁
public void close() {
    // Put any closing code here, like joining Threads or whatever
    System.exit(0); // 0 means it is a normal exit, i.e. there are no errors
}