使用多线程交替打印数字和字母数组

这个题我起初一看就觉得很像生产消费者模型，然后看了网上的一些帖子，给了完整代码的帖子很少，然后尝试自己写了一下确实和生产消费者模型类似，其本质还是线程通信；

线程通信无外乎sychronized线程锁，而落地到实质的方法上是wait（）和notify（）方法。我这里给出解释：
wait（）：称作线程在对象上的等待，作用是把当前的线程放入对象的等待集合中。
notify（）：从该对象的等待集合中选择一个等待的线程唤醒，唤醒的线程将从等待集合中删除。顺序唤醒

当然这个题是得对线程同步有一定理解，基础概念大家也应该需要清楚。锁实际上是锁的一个对象，这里搞这个线程通信就最好把资源放在一个对象中，好锁嘛。 然后用线程去调用这个对象的资源。
这是我的完整代码，实际上挺好理解的，就是利用假死锁的方式去完成线程暂停：

package 线程;

/**
 * @className list
 * @Description TODO
 * @Autor WUAO
 * @Date 2022/9/9 02 02
 */
public class ThreadTest {
    public static void main(String[] args) {
        test tst=new test();
            Thread t1=new Thread(()->{
                try {
                    tst.printA();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            Thread t2=new Thread(()->{
                try {
                    tst.printB();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            t1.start();
            t2.start();
    }
}
class test{
    public int a[]={1,2,3,4};
    public char b[]={'a','b','c','d'};

    public Boolean flag=true;
    public synchronized void  printA() throws InterruptedException {
      int count=0;
      while(count<a.length){

          if(flag){
              System.out.println(a[count++]);
              flag=false;
          }else{
              //称作线程在对象上的等待，作用是把当前的线程放入对象的等待集合中。
              wait();
          }
          //从该对象的等待集合中选择一个等待的线程唤醒，唤醒的线程将从等待集合中删除。顺序唤醒
          notify();
      }

    }
    public synchronized void  printB() throws InterruptedException {
        int count=0;
        while(count<b.length){
            if(!flag){
                System.out.println(b[count++]);
                flag=true;
            }else{
                wait();
            }
            notify();
        }

    }
}