我希望你正在寻找这样的东西：

public class MaltiThreadExample {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));

        for (int i : list) {
            Thread th = new Thread() {
                @Override
                public void run() {
                    System.out.println(i);
                }
            };
            th.start();
        }
    }

}

输出是针对一次执行的：

run:
3
1
2
BUILD SUCCESSFUL (total time: 0 seconds)

是的，这是一个典型的“生产者-消费者”范式：
假设一个Runnable类接收一个Iterator作为参数，等待某个监视器，然后消耗迭代器中的一个项，最后通知同一个监视器，当迭代器有更多项时循环。
在此基础上，创建数字列表、创建消费者线程（向它们传递列表的迭代器）并启动它们就足够了。

下面的代码根本没有经过测试，只是在脑海中出现的一些东西，最后一个使用parallelStream（）的实现可能就是你要找的。

public class DemoApplication {

    public static void main(String[] args) {
        final List<Integer> myIntegerList = Arrays.asList(1, 2, 3);

        // Good old for-each-loop
        for (Integer item : myIntegerList) {
            System.out.print(item);
        }

        // Java 8 forEach with Consumer
        final Consumer<Integer> consumer = new Consumer<Integer>() {
            @Override
            public void accept(Integer item) {
                System.out.print(item);
            }
        };

        myIntegerList.forEach(consumer);

        // Java 8 forEach with Lambda
        myIntegerList.forEach((item) -> System.out.print(item));

        // Java 8 forEach on parallelStream with Lambda
        myIntegerList.parallelStream().forEach((item) -> System.out.print(item));
    }
}

我正在努力理解线程的优点。
在一个程序中使用多线程基本上有两个原因：

**（1）异步事件处理：**想象一个程序必须等待和响应几种不同类型的输入，每种输入可以在完全任意的时间发生。

在线程出现之前，我们常常编写一个大的“事件循环”，它会“轮询"每一种不同的”事件“，然后”分派“给不同的”处理器“函数。当一个或多个事件处理器是”有状态“的（即，它接下来做什么取决于之前事件的历史）时，事情可能会变得很糟糕。
一个程序为每种不同类型的事件都有一个线程，这样的程序通常更简洁，也就是说，它更容易理解，更容易修改，等等。每个线程只循环等待一种类型的事件，它的状态（如果有的话）可以保存在局部变量中，或者它的状态可以是隐式的（即取决于线程在任何给定时间所处的函数）。
（2）多处理（又称“并行处理”、“并发编程”等）：使用 * 工作线程 * 执行 * 后台计算 * 可能是目前使用最广泛的多处理模型。
多线程是所有多处理模型中最低级的，这意味着（a）它最难理解，但（b）它是最通用的。

这是可以做到的。我们可以利用concurrentashmap。我们可以将列表添加到这个Map中，并将其传递给线程。每个线程都会尝试获得资源上的锁来进行操作。