多线程交替打印某字符串

多线程交替打印某字符串

题目描述：对于给定长度为len的字符串target，使用len个线程将该字符串交替打印出来，每打印出一个完整的target为一轮，共需打印N轮。要求这len个线程同时运行。
例子：
1、target=“ABC” ，N=3 输出：“ABCABCABC”
2、target=“ae” ，N=3 输出：“aeaeae”

---

volatile方法

对于给定的长度为len的目标字符串target，可以考虑用一个线程数组保存需要开启的线程，数组下标为n的线程负责打印target[n]，使用volatile的共享变量shareValue 保存当前待打印的字符下标。对于第n个线程，在拿到共shareValue 后，判断n是否等于shareValue ，若相等，则打印字符，同时，shareValue =（shareValue +1）%len，否则循环判断。代码如下：

import java.util.concurrent.CountDownLatch;
public class MultiThreadPrint1 {
    //目标字符串
    String target;
    //需要打印的轮次
    int loop;
    //线程数组
    Thread[] threads;
    //记录当前需要打印的字符在target中的下标
    volatile int shareValue = 0;
    CountDownLatch countDownLatch;
    public MultiThreadPrint1(String target, int loop, CountDownLatch countDownLatch) {
        this.target = target;
        this.loop = loop;
        this.countDownLatch = countDownLatch;
        threads = new Thread[target.length()];
        for (int i = 0; i < target.length(); i++) {
            Runnable runnable = new PrintRunnable(i, target.charAt(i));
            Thread thread = new Thread(runnable);
            threads[i] = thread;
        }
    }
    class PrintRunnable implements Runnable {
        int printIndex;
        char printTarget;

        public PrintRunnable(int printIndex, char printTarget) {
            this.printIndex = printIndex;
            this.printTarget = printTarget;
        }

        @Override
        public void run() {
            int count = loop;
            while (count > 0) {
                count--;
                while (true) {
                    if (shareValue == printIndex) {
                        System.out.print(printTarget);
                        shareValue = (shareValue + 1) % target.length();
                        break;
                    }
                }
            }
            countDownLatch.countDown();
        }
    }
}


//main
import java.util.concurrent.CountDownLatch;

public class TesT {
    public static void main(String[] args) throws InterruptedException {
        Long startTime = System.currentTimeMillis();
        String target = "bc#qwe#";
        CountDownLatch countDownLatch = new CountDownLatch(target.length());
        MultiThreadPrint3 multiThreadPrint = new MultiThreadPrint3(target, 10000, countDownLatch);
        for (int i = 0; i < target.length(); i++) {
            multiThreadPrint.threads[i].start();
        }
        countDownLatch.await();
        System.out.println();
        System.out.println("耗时:" + String.valueOf(System.currentTimeMillis() - startTime));
    }

}

Lock+Condition

对于以上的方法，当所开启的线程较少时，性能较高，但随着线程数量的增加，性能将急剧下降。因为每个线程都在不需要自己打印字符时，会不断的进行轮询，十分消耗性能。为了解决这一问题，必须想办法让线程在不需要打印字符时，将自身挂起等待，等满足打印条件后，再对其进行唤醒，继而执行打印字符操作。在Java中，可以使用Lock+Condition的方法实现这一目的。
假如有A、B、C三个线程分别负责打印字符A、B、C，则它们之间的唤醒链如下:

具体代码如下：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiThreadPrint {
    String target;
    int loop;
    int printIndex;
    Thread[] threads;
    Condition[] conditions;
    Lock lock;
    CountDownLatch countDownLatch;
    
    public MultiThreadPrint(String target, int loop, CountDownLatch countDownLatch) {
        this.target = target;
        this.loop = loop;
        this.printIndex = 0;
        this.lock = new ReentrantLock();
        this.countDownLatch = countDownLatch;
        conditions = new Condition[target.length()];
        threads = new Thread[target.length()];
        for (int i = 0; i < target.length(); i++) {
            Condition condition = lock.newCondition();
            conditions[i] = condition;
            Runnable runnable = new PrintRunnable(i, target.charAt(i));
            Thread thread = new Thread(runnable);
            threads[i] = thread;
        }
    }

    class PrintRunnable implements Runnable {
        //当前线程所在线程数组的下标
        int threadIndex;
        //当前线程需要唤醒的线程所在线程数组的下标
        int notifyThread;
        //当前线程需要打印的字符
        char printTarget;
        public PrintRunnable(int threadIndex, char printTarget) {
            this.threadIndex = threadIndex;
            this.printTarget = printTarget;
            this.notifyThread = (threadIndex + 1) % target.length();
        }

        @Override
        public void run() {
            int count = loop;
            while (count > 0) {
                count--;
                lock.lock();
                try {
                    while (printIndex != threadIndex) {
                        conditions[threadIndex].await();
                    }
                    System.out.print(printTarget);
                    printIndex = (printIndex + 1) % target.length();
                    //通知下一个线程，最后一个线程需要通知第一个线程
                    conditions[notifyThread].signal();
                } catch (Exception e) {
                    System.out.println("ERROR");
                }finally {
                    lock.unlock();
                }
            }
            countDownLatch.countDown();
        }
    }
}

LockSupport

Lock+Condidion的通知唤醒机制是使用的LockSupport.park和LockSupport.unpark，针对这一题，我们其实并不需要加锁这一过程，所需要的只是让当前不打印字符的线程挂起等待而已，因此，本题中我们可以直接利用LockSupport提供的唤醒/等待机制来实现多线程的交替打印。代码如下：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.LockSupport;

public class MultiThreadPrint3 {
    String target;
    int loop;
    Thread[] threads;
    CountDownLatch countDownLatch;
    int printIndex;

    public MultiThreadPrint3(String target, int loop, CountDownLatch countDownLatch) {
        this.target = target;
        this.loop = loop;
        this.printIndex = 0;
        this.countDownLatch = countDownLatch;
        threads = new Thread[target.length()];
        for (int i = 0; i < target.length(); i++) {
            Runnable runnable = new PrintRunnable(i, target.charAt(i));
            Thread thread = new Thread(runnable);
            threads[i] = thread;
        }
    }

    class PrintRunnable implements Runnable {
        int threadIndex;
        int notifyThread;
        char printTarget;
        public PrintRunnable(int threadIndex, char printTarget) {
            this.threadIndex = threadIndex;
            this.printTarget = printTarget;
            this.notifyThread = (threadIndex + 1) % target.length();
        }
        @Override
        public void run() {
            int count = loop;
            while (count > 0) {
                count--;
                while (printIndex != threadIndex) {
                    LockSupport.park();
                }
                System.out.print(printTarget);
                printIndex = (printIndex + 1) % target.length();
                LockSupport.unpark(threads[notifyThread]);
            }
            countDownLatch.countDown();
        }
    }
}

总结

这一题考察的是对Java多线程的理解，在本文所给出的三种解法中，第三种解法是最为简单高效的。