要求用线程顺序打A1B2C3....Z2

问题描述

要求用线程顺序打A1B2C3…Z2

思路

1. 利用生产者消费者思路，将打印字母进程看做生产者，消费字母消费一个，但这里的消费不是消费的字母，则是消费者消费逻辑为打印数字，利用两个信号量分别为t1Condition 、t2Condition，字符生产者生产打印后通知消费者打印数字， 反之亦然。

代码

利用BlockingQueue阻塞队列实现

/**
 * 描述: 要求用线程顺序打A1B2C3....Z26
 */

/**
 * 描述: BlockingQueue的含义
 * 标准的生产者消费者模式，当队列中不为null则，.take可以取到数据，不用陷入等待，如果为null，当线程去拿时会发现不能获取到数据
 * 这时，该线程就会陷入等待，需要put进去一个参数，才能take到。
 */

public class T01_06_Question {

    //设置两个任务队列，允许最大值为1
    static BlockingQueue<String> p1 = new ArrayBlockingQueue<String>(1);
    static BlockingQueue<String> p2 = new ArrayBlockingQueue<String>(1);


    public static void main(String[] args) {
        new Thread(() -> {
            try {
                for (int i = 0; i < 26; i++) {
                    System.out.print((char) ('A' + i));
                    //必须有一个先唤醒，不然会发生死锁状态，如果t1 await后唤醒t2，然后马上t2 await两个线程都处于await状态

                    //将t2Condition唤醒，这时还未释放锁，继续往下执行
                    //设置p2的值，这时在另外线程中p2线程就可以取到值，不会等待
                    p2.put("ok");
                    //在队列中获取一个值，当队列中为空时，这时就会陷入等待，需要另外一个线程放入一个或多个（最大值不为1）才能唤醒
                    p1.take();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }).start();


        new Thread(() -> {
            try {
                for (int i = 0; i < 26; i++) {
                    p1.put("ok");
                    p2.take();
                    System.out.print(i + 1);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }).start();
    }
}

利用TransferQueue的实现

/**
 * 描述: 要求用线程顺序打A1B2C3....Z26
 */

/**
 * 描述: TransferQueue的作用
 * 就相当于生产者消费者模式，将一个对象transfer进队列中，即生产，等待别的线程来消费该对象
 * take()用来消费，当队列中没有对象时，相当于没有产品，得等待生产者生产产品以供消费者消费，
 * 即这里的用两个线程相互打印对方的信息
 */


public class T01_08_Question {


    public static void main(String[] args) throws IOException {

        char[] aC = new char[26];

        for (int i = 0; i < 26; i++) {
            aC[i] = (char) (i + 49);
        }

        TransferQueue<String> queue = new LinkedTransferQueue<>();

        new Thread(() -> {
            byte[] buffer = new byte[30];
            try {
                for (int i = 0; i < 26; i++) {
                    //消费对方线程生产的数字
                    System.out.print(queue.take());
                    //生产字母等对方线程消费
                    queue.transfer((char) ('A' + i) + "");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }).start();


        new Thread(() -> {
            byte[] buffer = new byte[20];
            try {
                for (int i = 0; i < 26; i++) {
                    //生产数字等对方线程消费
                    queue.transfer(i + 1 + "");
                    //消费对方线程生产的字母
                    System.out.print(queue.take());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }).start();
    }
}

利用ReentrantLock实现

/**
 * 描述: 要求用线程顺序打A1B2C3....Z26
 */
public class T01_05_Question {

    static ReentrantLock lock = new ReentrantLock();
    static Condition t1Condition = lock.newCondition();
    static Condition t2Condition = lock.newCondition();


    public static void main(String[] args) {
        new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 26; i++) {
                    System.out.print((char) ('A' + i));
                    //必须有一个先唤醒，不然会发生死锁状态，如果t1 await后唤醒t2，然后马上t2 await两个线程都处于await状态
                    //t1Condition.await();
                    //将t2Condition唤醒，这时还未释放锁，继续往下执行
                    t2Condition.signal();
                    //将自己陷入等待
                    t1Condition.await();
                }
                //打印完毕，唤醒t2Condition 继续往下执行，
                t2Condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //lock方式加锁，需要将其手动释放
                lock.unlock();
            }
        }).start();


        new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 26; i++) {
                    //将t1Condition唤醒，这时还未释放锁，继续往下执行
                    t1Condition.signal();
                    //将自己陷入等待
                    t2Condition.await();
                    System.out.print(i + 1);
                }
                //打印完毕，唤醒t1Condition 继续往下执行，
                t1Condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //lock方式加锁，需要将其手动释放
                lock.unlock();
            }

        }).start();
    }
}