有一个任务队列，分别有A、B、C三种类型的任务，设计一种功能，让三种任务分别按照x:y:z（具体比例可配置）的比例进行执行

朋友的面试题，如下

有一个任务队列，分别有A、B、C三种类型的任务，设计一种功能，让三种任务分别按照x:y:z（具体比例可配置）的比例进行执行

解之。
主要的思路是lock+condition处理任务调度。

package test;

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

/**
 * 有一个任务队列，分别有A、B、C三种类型的任务，设计一种功能， 让三种任务分别按照x:y:z（具体比例可配置）的比例进行执行
 * 
 */
public class Test {
    /*
     * 抽象具体化：比如有一个打印的功能，A任务打印A，以此类推 按照比例1：1：1执行，ABC 按照比例2:3:2执行，AABBBCC
     * 需三个线程分别处理三个任务，线程任务调度机制lock/condition
     */
    static Lock lock = new ReentrantLock();
    static Condition conA = lock.newCondition();
    static Condition conB = lock.newCondition();
    static Condition conC = lock.newCondition();
    static int a = 0, b = 0, c = 0, count, sum = 0;
    static Boolean flag = false;

    public static void main(String[] args) {
        count = 10; // 任务总数
        a = 1; // A任务比例
        b = 2; // B任务比例
        c = 1; // C任务比例
        new Thread(new TaskA()).start();
        new Thread(new TaskB()).start();
        new Thread(new TaskC()).start();
    }

    static class TaskA implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (lock.tryLock()) {
                    try {
                        for (int i = 0; i < a; i++) {
                            if (sum == count) {
                                return;
                            }
                            System.out.print("A");
                            sum++;
                        }
                        conB.signal();
                        conA.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }
    }

    static class TaskB implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (lock.tryLock()) {
                    try {
                        for (int i = 0; i < b; i++) {
                            if (sum == count) {
                                return;
                            }
                            System.out.print("B");
                            sum++;
                        }
                        conC.signal();
                        conB.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }
    }

    static class TaskC implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (lock.tryLock()) {
                    try {
                        for (int i = 0; i < c; i++) {
                            if (sum == count) {
                                return;
                            }
                            System.out.print("C");
                            sum++;
                        }
                        conA.signal();
                        conC.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }
    }

}