方法一：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();
}
