三个Java多线程循环打印递增的数字，每个线程打印5个数值，打印周期1-75

打印数值线程类

package com.volitation.bigdata.holder.thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 打印数值线程
 * 
 * @author volitation
 *
 */
public class PrintNumberThread implements Runnable {

    private static int counter = 1;

    private final int id = counter++;
    /*
     * volatile 关键字作用是，使系统中所有线程对该关键字修饰的变量共享可见，可以禁止线程的工作内存对volatile修饰的变量进行缓存。
     */
    private static volatile int num = 0;
    // 创建同步辅助类
    private CyclicBarrier cyclicBarrier;

    public PrintNumberThread(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }

    // 创建同步锁
    public synchronized int getNum() {
        return num;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // cyclicBarrier的await()方法，在所有参与者都已经在此cyclicBarrier上调用 await方法之前，将一直等待。
                cyclicBarrier.await();
            }
        } catch (InterruptedException e) {
        } catch (BrokenBarrierException e) {
            throw new RuntimeException(e);
        }
    }

    public void printNum() {
        for (int i = 1; i <= 5; i++) {
            System.out.print("线程" + id + ":");
            System.out.println(++num);
        }
    }
}

测试主类

package com.volitation.bigdata.holder.tests;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import com.volitation.bigdata.holder.thread.PrintNumberThread;

/**
 * 打印数值线程测试类
 * 
 * @author volitation
 *
 */
public class PrintNumberThreadTest {

    static final int FINAL_NUM = 75;

    private List<PrintNumberThread> listPrintNumberThread = new ArrayList<>();
    // 创建线程池
    private ExecutorService executorService = Executors.newCachedThreadPool();
    // 创建同步辅助类
    private CyclicBarrier cyclicBarrier;

    /**
     * 初始化
     * 
     * @param threads
     *              线程数量
     * @param sleepTime
     *              休眠时间
     */
    public PrintNumberThreadTest(int threads, final int sleepTime) {
        cyclicBarrier = new CyclicBarrier(threads, new Runnable() {

            @Override
            public void run() {
                for (PrintNumberThread printNumberThread : listPrintNumberThread)
                    if (printNumberThread.getNum() >= FINAL_NUM) {
                        // 关闭线程池
                        executorService.shutdownNow();
                        return;
                    } else {
                        printNumberThread.printNum();
                    }
            }
        });
        try {
            // 创建线程休眠
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < threads; i++) {
            PrintNumberThread printNumberThread = new PrintNumberThread(cyclicBarrier);
            listPrintNumberThread.add(printNumberThread);
            // 异步执行Runnable实例
            executorService.execute(printNumberThread);
        }
    }

    public static void main(String[] args) {
        new PrintNumberThreadTest(3 , 100);
    }
}

测试结果

线程1:1
线程1:2
线程1:3
线程1:4
线程1:5
线程2:6
线程2:7
线程2:8
线程2:9
线程2:10
线程3:11
线程3:12
线程3:13
线程3:14
线程3:15
……
线程3:71
线程3:72
线程3:73
线程3:74
线程3:75