Java多线程循环打印ABC等问题

末蓝、 2023-02-11 10:16 39阅读 0赞

### 前言 ###

有很多中写法，希望可以慢慢都写出来。

### 1、线程共享类对象：依靠AtomicInteger是线程安全的 ###

将 AtomicInteger currentCount 作为线程共享。

import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * 三个线程按次序轮流打印a,b,c AtomicInteger 实现
     *
     */
    public class AtomicIntegerThread implements Runnable {
        private AtomicInteger currentCount = new AtomicInteger(0);
    
        private static final Integer MAX_COUNT = 6;
    
        private static String[] chars = {"a", "b", "c"};
    
        private String name;
    
        public AtomicIntegerThread(String name,AtomicInteger currentCount) {
            this.name = name;
            this.currentCount = currentCount;
        }
    
        @Override
        public void run() {
            while (currentCount.get() < MAX_COUNT) {
                if (this.name.equals(chars[currentCount.get() % 3])) {
                    printAndPlusOne(this.name);
                }
            }
        }
    
        public void printAndPlusOne(String content) {
            System.out.print(content);
            currentCount.getAndIncrement();
        }
    
        public static void main(String[] args) {
            
            AtomicInteger currentCount = new AtomicInteger(0);
    
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
            threadPoolExecutor.execute(new AtomicIntegerThread("a",currentCount));
            threadPoolExecutor.execute(new AtomicIntegerThread("b",currentCount));
            threadPoolExecutor.execute(new AtomicIntegerThread("c",currentCount));
            threadPoolExecutor.shutdown();
            
        }
    }

这里一定要注意有一个坑，如果线程池核心线程数少于3个，1个或者2个，上述代码会有问题，因为线程池的队列是无界队列，多余核心线程数的任务会被放到队列中，这样循环打印的时候，有一些线程不是在运行中的，是在队列里的，运行中的线程会被阻塞，导致相互等待，死锁问题出现。所以线程池的核心线程数必须等于大于3个，这样保证有3个线程一直在运行。

### 2、volatile静态变量控制 ###

还有一种就是将某个变量设置为静态，这样线程本身也共享该变量，则可以对其操作。但要注意给这个静态变量加上volatile字段，这个字段可以帮助多线程中的可见性。代码如下：

import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 三个线程按次序轮流打印a,b,c
     *
     */
    public class StaticVarThread implements Runnable {
    
            private static volatile Integer currentCount = 0;
    
    
        private static final Integer MAX_COUNT = 6;
    
        private static String[] chars = {"a", "b", "c"};
    
        private String name;
    
        public StaticVarThread(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            while (currentCount < MAX_COUNT) {
                try {
                    while (this.name.equals(chars[currentCount % 3]) && currentCount < MAX_COUNT) {
                        printAndPlusOne(this.name);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                }
            }
        }
    
        public void printAndPlusOne(String name) {
            System.out.println(name + "\t" + currentCount);
            currentCount++;
        }
    
        public static void main(String[] args) {
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
            threadPoolExecutor.execute(new StaticVarThread("a"));
            threadPoolExecutor.execute(new StaticVarThread("b"));
            threadPoolExecutor.execute(new StaticVarThread("c"));
            threadPoolExecutor.shutdown();
        }
    }

### 3、synchronized对象加锁 ###

利用一个计数来除线程个数得到余数从而控制线程输出，并且利用synchronized、一个Object的wait()和notify()方法来对线程的阻塞和唤醒，这里的技巧可以看看。

*  wait()  
    阻塞当前线程，等待被释放，继续执行当前线程
 *  notify()  
    唤醒监视该对象的第一个线程，notifyAll()唤醒监视该对象的所有线程。

代码：

static volatile int state; // 线程共有，判断所有的打印状态
        static final Object t = new Object(); // 线程共有，加锁对象
    
    /**
         * 改装了一下
         */
        @Test
        public void mainSix() {
            state = 0;
            // 需要循环的次数
            int n = 3;
            int num = 2;
    
            new MyThread("A", 0, n, num).start();
            new MyThread("B", 1,  n, num).start();
        }
    
    
        class MyThread extends Thread {
            String name;
            int which; // 标示符：0：打印A；1：打印B；2：打印C
            int n; // 0：打印次数
            int num; // 循环周期
    
    
            public MyThread(String name,int which,int n,int num) {
                this.name = name;
                this.which = which;
    
                this.n = n;
                this.num = num;
            }
    
            @Override
            public void run() {
                for (int i = 0; i < n; i++) {
                    synchronized (t) {
                        while (state % num != which) {
                            try {
                                t.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.print(name); // 执行到这里，表明满足条件，打印
                        state++;
                        t.notify(); // 调用notifyAll方法
                    }
                }
            }
        }

### 4、condition 与lock的结合 ###

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与lock 对象的newCondition() 方法，condition 是lock对象所创建的，在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，其突出的优点有：

*  Condition能够支持不响应中断，而通过使用Object方式不支持；
 *  Condition能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个；
 *  Condition能够支持超时时间的设置，而Object不支持
 *  调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

使用场景：多个condition的唤醒机制，比如多个生产者同时生产，多个消费者同时消费，需要两个condition来唤醒，或者是有先后顺序执行的线程，比如顺序打印ABC。  
Condition是基于AQS同步机制的同步方法。 AbstractQueuedSynchronizer（AQS）。

import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ConditionTwo extends Thread {
    
        private Lock lock;
    
        private int count;
    
        private String str;
        private int flag;
        Condition A;
        Condition B;
    
        public ConditionTwo(String str, int flag, int count, Lock lock, Condition A, Condition B) {
            this.str = str;
            this.flag = flag;
            this.A = A;
            this.B = B;
            this.count = count;
            this.lock = lock;
        }
    
        @Override
        public void run() {
            try {
                lock.lock();
                while (count<2) {
                    System.out.println(" str = " + str+" count =" +count);
                    count++;
                    // 唤醒 B 线程
                    B.signal();
                    // 暂停自己进程
                    A.await();
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                B.signal();
                lock.unlock();
            }
        }
    
    
        public static void main(String[] args) throws InterruptedException {
    
            Lock lock = new ReentrantLock();
    
            int count = 0;
    
            Condition A = lock.newCondition();
            Condition B = lock.newCondition();
            Condition C = lock.newCondition();
    
            new ConditionTwo("a", 0,count,lock, A, B).start();
            
            // 必须要加 这个限制，不然可能不是a 先执行
            
            Thread.sleep(500);
            
            new ConditionTwo("b", 1,count,lock,  B, C).start();
            new ConditionTwo("c", 2,count,lock,  C, A).start();
            
        }
    }

### 参考博客 ###