方法一：CAS

每个线程自旋获取是否打印标识，利用原子类实现（AtomicInteger）,
实现简单但是性能不友好

方法二：Object的wait/notify 阻塞和唤醒机制

wait():让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)

notify()和notifyAll():则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

  Object object = new Object();
        new Thread(() -> {
            synchronized (object) {
                for (int i = 0; i < 10; i++) {
                    System.out.println("A");//唤醒一个线程
                    object.notify();
                    
                    try {
                        object.wait();//当前线程挂起，被另一个线程唤醒后，继续执行后面的代码
                      //这里就是继续下一步for循环
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                object.notify();
            }
        }).start();
           
        //想要A先输出，这里得sleep,否则有可能输出BABA
        Thread.sleep(100L);
 
        new Thread(() -> {
            synchronized (object) {
                for (int i = 0; i < 10; i++) {
                     System.out.println("B");
                    object.notify();//唤醒一个线程
                   
                    try {
                        object.wait();//当前线程挂起
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                object.notify();
            }
        }).start();

当多个线程同时访问一个线程安全方法时我们可以使用synchronized关键字来给方法加锁。
当某个线程需要访问方法时,会先获取访问该方法的锁，当访问完毕再释放锁。当多个线程在等待调用队列中，操作系统根据一定的调度算法，取出下一个线程来执行方法，完成方法的并行到串行的执行过程。每个对象都拥有一个Monitor，我们可以将Monitor理解为对象的锁。每个线程访问任意对象时必须要先获取该对象的Monitor 才能访问。当synchro-nized修饰一个对象时，它控制多线程访问该对象的方法正是通过对象的Monitor实现。

对象的wait()是让当前线程释放该对象Monitor锁并且进入访问该对象的等待队列，当前线程会进入挂起状态，等待操作系统唤起(notify)，挂起的线程重新获取对该对象的访问锁才能进入运行状态。因为自身已经挂起，所以已经挂起的线程无法唤醒自己，必须通过别的线程告诉操作系统，再由操作系统唤醒。
Monitor是不能被并发访问的(否则Monitor状态会出错，操作系统根据错误的状态调度导致系统错乱)，

而wait和nofity 正是改变Monitor的状态，所以使用wait、notify方法时，必须对对象使用synchronized加锁，只有线程获取对象的Monitor锁之后才能进行wait、notify操作否则将抛出IllegalMonitorStateException异常

方法三：利用Semaphore信号量

Semaphore概述： Semaphore是一种计数信号量，用于控制对共享资源的访问。它维护了一个内部计数器，表示可用的许可数量。线程可以通过获取许可来访问资源，并在使用完资源后释放许可。如果许可数量为0，则获取许可的线程将被阻塞，直到有其他线程释放许可为止。底层是基于AQS实现的。

初始化Semaphore对象，指定初始许可数量。
线程通过调用acquire()方法获取许可，如果许可数量不足，线程将被阻塞。
线程在使用完资源后，通过调用release()方法释放许可。
可以通过availablePermits()方法获取当前可用的许可数量

    void print() {
        Semaphore semaphore1 = new Semaphore(1);
        Semaphore semaphore2 = new Semaphore(0);
        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore1.acquire();
                    System.out.println("A");
                    semaphore2.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //Thread.sleep(1000L),相比于方法3&4这里的睡眠时间不需要了
        // semaphore2信号量初始化为0，t2线程执行acquire()会阻塞，当t1执行semaphore2.release()后t2才会执行
        new Thread(()-> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore2.acquire();
                    System.out.println("B");
                    semaphore1.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
 
    }

Semaphore vs. Lock：

Semaphore和Lock（如ReentrantLock）都可以用于线程之间的互斥访问控制。它们的区别在于：

• Semaphore允许多个线程同时访问资源，而Lock一次只允许一个线程访问资源。
• Semaphore是基于计数的机制，可以控制同时访问的线程数量，而Lock只是简单的互斥锁。 根据具体场景，选择Semaphore还是Lock取决于对资源的访问控制需求。

Semaphore vs. Condition：

Semaphore和Condition都可以用于线程之间的同步和通信，但在不同的场景下有不同的用途：

• Semaphore主要用于控制对资源的访问，限制并发线程的数量。

• Condition主要用于线程之间的协调，可以通过await()和signal()等方法实现线程的等待和唤醒。

Semaphore的适用场景：

Semaphore在以下场景中特别有用：

• 控制对有限资源的并发访问，如数据库连接池、线程池等。
• 限制同时执行某个操作的线程数量，如限流和限制并发请求等。
• 在生产者-消费者模式中平衡生产者和消费者之间的速度差异。

方法四: Lock和Condition的方式

    Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    void print() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    System.out.println("A");
                    //唤醒c2，c1阻塞，（c1唤醒c2）如此循环
                   c2.signal();                    
                   c1.await();
     
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }).start();
 
        try {
            //确保t1已经阻塞
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    System.out.println("B");
                    c1.signal();  //唤醒c1，c2阻塞，（c2唤醒c1）如此循环
                    c2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }).start();
 
 
    }

方法五：ReentranLock公平锁

 Lock lock = new ReentrantLock(true);
    volatile int printFlag = 0;
    void print() {
        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                lock.lock();
                try {
                    if(printFlag == 0){
                        System.out.println("A");
                        i++;
                        printFlag = 1;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
        
        new Thread(() -> {
            for (int i = 0; i < 10;) {
                lock.lock();
                try {
                    if(printFlag == 1){
                        System.out.println("B");
                        i++;
                        printFlag = 0;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();

方法六：阻塞队列

利用阻塞队列take方法，队列为空时，阻塞；

  private BlockingQueue<Integer> queueA = new LinkedBlockingQueue<Integer>() {{
        add(0);
    }};
    private BlockingQueue<Integer> queueB = new LinkedBlockingQueue<>();
 
    void print() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++ ) {
                try {
                    queueA.take();
                    System.out.println("A");
                    queueB.add(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
 
        new Thread(() -> {
            for (int i = 0; i < 10;i++) {
                try {
                    queueB.take();
                    System.out.println("B");
                    queueA.add(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }