帮我用java写一个线程套线程执行任务的demo

以下是一个简单的Java线程套线程执行任务的demo代码：

public class ThreadDemo {

    public static void main(String[] args) {
        // 创建一个父线程
        Thread parentThread = new Thread(new ParentRunnable());
        parentThread.start();
    }

    // 定义一个父线程的任务
    static class ParentRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Parent thread started.");

            // 创建一个子线程
            Thread childThread = new Thread(new ChildRunnable());
            childThread.start();

            // 父线程等待子线程执行完毕
            try {
                childThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Parent thread finished.");
        }
    }

    // 定义一个子线程的任务
    static class ChildRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Child thread started.");

            // 子线程再创建一个孙子线程
            Thread grandsonThread = new Thread(new GrandsonRunnable());
            grandsonThread.start();

            // 子线程等待孙子线程执行完毕
            try {
                grandsonThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Child thread finished.");
        }
    }

    // 定义一个孙子线程的任务
    static class GrandsonRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Grandson thread started.");
            System.out.println("Grandson thread finished.");
        }
    }
}

在上述代码中，我们定义了三个不同的Runnable实现类，即ParentRunnable、ChildRunnable和GrandsonRunnable，分别代表父线程、子线程和孙子线程的任务。在ParentRunnable任务中，我们创建了一个子线程，然后等待子线程执行完毕。在ChildRunnable任务中，我们再创建了一个孙子线程，然后等待孙子线程执行完毕。最后，所有线程都执行完毕，程序输出以下结果：

Parent thread started.
Child thread started.
Grandson thread started.
Grandson thread finished.
Child thread finished.
Parent thread finished.

可以看到，这个程序是通过线程套线程的方式来执行任务的，每个线程都等待它的子线程执行完毕后再继续执行。这种方式可以用于执行复杂的任务，将任务拆分成多个子任务，然后分别交给不同的线程去执行，从而提高程序的执行效率。