Java多线程Demo

逃离我推掉我的手 2022-06-14 09:26 189阅读 0赞

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

#### 1）打印数值线程类 ####

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);
            }
        }
    }

#### 2）测试主类 ####

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);
        }
    }

#### 3）测试结果 ####

> 线程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