经典面试题-2条线程交错打印数据

问题描述
利用2条线程，一条线程输出A-Z，另一条线程输出1-26，输出要求为A1B2C3…Z26

废话不多说，直接上答案

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

public class PrintTest {
    static Thread t1 = null, t2 = null;
    static Lock lock = new ReentrantLock();
    static Condition c1 = lock.newCondition();
    static Condition c2 = lock.newCondition();
    static volatile int k = 0;
    public static void main(String[] args) throws InterruptedException {
//        方法一： 利用ReentrantLock condition， 2条等待队列
//        t1  = new Thread(()->{
//            lock.lock();
//            for (int i = 1; i <= 26; i++) {
//                System.out.println((char)(64+i) + ":" + i);
//                try {
//                    c2.signal();
//                    c1.await();
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
//            c1.signal();
//            c2.signal();
//            lock.unlock();
//        },"t1");
//
//        t2  = new Thread(()->{
//            lock.lock();
//            for (int j = 1; j <=26; j++) {
//                System.out.println(j);
//                try {
//                    c1.signal();
//                    c2.await();
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
//            c1.signal();
//            c2.signal();
//            lock.unlock();
//        },"t2");
//
//        t1.start();
//        t2.start();

//      基础方法利用 synchronized， notify， wait
        Object oLock = new Object();
        t1 = new Thread(()->{
           synchronized (oLock){
               for (int i = 1; i <= 26; i++) {
                   if (k==1){
                       System.out.println((char)(64+i) + ":" + i);
                       k = 0;
                       try {
                           oLock.notify();
                           oLock.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }else{
                       try {
                           oLock.notify();
                           oLock.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
               //唤醒所有等待线程， 用于程序正常退出
               oLock.notifyAll();
           }
        });

        t2 = new Thread(()->{
            synchronized (oLock){
                for (int j=1; j<=26; j++){
                    if (k == 0){
                        System.out.println(j);
                        k = 1;
                        oLock.notify();
                        try {
                            oLock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        oLock.notify();
                        try {
                            oLock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                //唤醒所有等待线程， 用于程序正常退出
                oLock.notifyAll();
            }
        });
        t1.start();
        t2.start();
    }
}