Java五种方式实现多线程循环打印问题

想要实现多线程循环打印问题，可以使用Java中的五种方式，包括继承Thread类、实现Runnable接口、实现Callable接口、使用线程池和使用定时器Timer。

继承Thread类

继承Thread类是实现多线程的一种方式，需要重写Thread类的run()方法来创建线程。代码示例如下：

public class ThreadDemo extends Thread {
    private String name;
    public ThreadDemo(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for(int i = 0; i < 3; i++) {
            System.out.println(name + "：" + i);
        }
    }

    public static void main(String[] args) {
        ThreadDemo t1 = new ThreadDemo("线程1");
        ThreadDemo t2 = new ThreadDemo("线程2");
        t1.start();
        t2.start();
    }
}

实现Runnable接口

另一种方式是实现Runnable接口来创建线程，也需要重写run()方法。相比继承Thread类，实现Runnable接口更为灵活，也更容易实现代码的复用。代码示例如下：

public class RunnableDemo implements Runnable {
    private String name;

    public RunnableDemo(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for(int i = 0; i < 3; i++) {
            System.out.println(name + "：" + i);
        }
    }

    public static void main(String[] args) {
        RunnableDemo rd1 = new RunnableDemo("线程1");
        RunnableDemo rd2 = new RunnableDemo("线程2");
        Thread t1 = new Thread(rd1);
        Thread t2 = new Thread(rd2);
        t1.start();
        t2.start();
    }
}

实现Callable接口

实现Callable接口的方式和实现Runnable接口的方式类似，也需要重写call()方法。不同的是，实现Runnable接口的run()方法不会返回值，而实现Callable接口的call()方法会返回一个值，可以使用FutureTask来获取返回值。代码示例如下：

public class CallableDemo implements Callable<String> {
    private String name;

    public CallableDemo(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        String result = "";
        for(int i = 0; i < 3; i++) {
            result += name + "：" + i + "\n";
        }
        return result;
    }

    public static void main(String[] args) {
        CallableDemo cd1 = new CallableDemo("线程1");
        CallableDemo cd2 = new CallableDemo("线程2");
        FutureTask<String> task1 = new FutureTask<>(cd1);
        FutureTask<String> task2 = new FutureTask<>(cd2);
        new Thread(task1).start();
        new Thread(task2).start();
        try {
            System.out.println(task1.get());
            System.out.println(task2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

使用线程池可以更好地管理线程，避免线程数量过多导致系统资源的浪费。Java中提供了ThreadPoolExecutor类来实现线程池的创建，利用execute()方法将Runnable或Callable对象提交给线程池进行执行。代码示例如下：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        for(int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " run.");
                }
            });
        }
        executor.shutdown();
    }
}

使用定时器Timer

使用定时器Timer也可以实现多线程的循环打印问题。使用Timer可以让任务在一定时间后执行，同时可以设置循环次数和延迟时间。代码示例如下：

public class TimerDemo {
    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            int count = 0;
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " run.");
                count++;
                if(count >= 3) {
                    cancel();
                }
            }
        };
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,0, 2000);
    }
}

以上五种方式均可以实现多线程的循环打印问题，具体选择哪种方式要根据具体的情况进行判断。