方法一：CAS
每個線程自旋獲取是否打印標(biāo)識丽惭，利用原子類實現(xiàn)（AtomicInteger）,
實現(xiàn)簡單但是性能不友好
方法二：Object的wait/notify 阻塞和喚醒機(jī)制
wait():讓當(dāng)前線程進(jìn)入等待狀態(tài)蛉谜，同時伴郁，wait()也會讓當(dāng)前線程釋放它所持有的鎖湖苞∵氲郏“直到其他線程調(diào)用此對象的 notify() 方法或 notifyAll() 方法”拌倍，當(dāng)前線程被喚醒(進(jìn)入“就緒狀態(tài)”)
notify()和notifyAll():則是喚醒當(dāng)前對象上的等待線程；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();//當(dāng)前線程掛起赐写，被另一個線程喚醒后鸟蜡，繼續(xù)執(zhí)行后面的代碼
//這里就是繼續(xù)下一步for循環(huán)
} 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();//當(dāng)前線程掛起
} catch (InterruptedException e) {
e.printStackTrace();
}
}
object.notify();
}
}).start();
當(dāng)多個線程同時訪問一個線程安全方法時我們可以使用synchronized關(guān)鍵字來給方法加鎖挺邀。
當(dāng)某個線程需要訪問方法時,會先獲取訪問該方法的鎖揉忘，當(dāng)訪問完畢再釋放鎖。當(dāng)多個線程在等待調(diào)用隊列中端铛，操作系統(tǒng)根據(jù)一定的調(diào)度算法泣矛，取出下一個線程來執(zhí)行方法，完成方法的并行到串行的執(zhí)行過程禾蚕。每個對象都擁有一個Monitor您朽，我們可以將Monitor理解為對象的鎖。每個線程訪問任意對象時必須要先獲取該對象的Monitor 才能訪問换淆。當(dāng)synchro-nized修飾一個對象時哗总，它控制多線程訪問該對象的方法正是通過對象的Monitor實現(xiàn)。
對象的wait()是讓當(dāng)前線程釋放該對象Monitor鎖并且進(jìn)入訪問該對象的等待隊列倍试，當(dāng)前線程會進(jìn)入掛起狀態(tài)讯屈，等待操作系統(tǒng)喚起(notify)，掛起的線程重新獲取對該對象的訪問鎖才能進(jìn)入運行狀態(tài)县习。因為自身已經(jīng)掛起涮母，所以已經(jīng)掛起的線程無法喚醒自己，必須通過別的線程告訴操作系統(tǒng)躁愿，再由操作系統(tǒng)喚醒叛本。
Monitor是不能被并發(fā)訪問的(否則Monitor狀態(tài)會出錯，操作系統(tǒng)根據(jù)錯誤的狀態(tài)調(diào)度導(dǎo)致系統(tǒng)錯亂)彤钟，
而wait和nofity 正是改變Monitor的狀態(tài)来候，所以使用wait、notify方法時样勃，必須對對象使用synchronized加鎖吠勘，只有線程獲取對象的Monitor鎖之后才能進(jìn)行wait、notify操作否則將拋出IllegalMonitorStateException異常
方法三：利用Semaphore信號量
Semaphore概述： Semaphore是一種計數(shù)信號量峡眶，用于控制對共享資源的訪問剧防。它維護(hù)了一個內(nèi)部計數(shù)器，表示可用的許可數(shù)量辫樱。線程可以通過獲取許可來訪問資源峭拘，并在使用完資源后釋放許可。如果許可數(shù)量為0，則獲取許可的線程將被阻塞鸡挠，直到有其他線程釋放許可為止辉饱。底層是基于AQS實現(xiàn)的。
初始化Semaphore對象拣展，指定初始許可數(shù)量彭沼。
線程通過調(diào)用acquire()方法獲取許可，如果許可數(shù)量不足备埃，線程將被阻塞姓惑。
線程在使用完資源后，通過調(diào)用release()方法釋放許可按脚。
可以通過availablePermits()方法獲取當(dāng)前可用的許可數(shù)量
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線程執(zhí)行acquire()會阻塞，當(dāng)t1執(zhí)行semaphore2.release()后t2才會執(zhí)行
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）都可以用于線程之間的互斥訪問控制辅搬。它們的區(qū)別在于：
- Semaphore允許多個線程同時訪問資源唯沮，而Lock一次只允許一個線程訪問資源。
- Semaphore是基于計數(shù)的機(jī)制堪遂，可以控制同時訪問的線程數(shù)量介蛉，而Lock只是簡單的互斥鎖。 根據(jù)具體場景蚤氏，選擇Semaphore還是Lock取決于對資源的訪問控制需求甘耿。
Semaphore vs. Condition：
Semaphore和Condition都可以用于線程之間的同步和通信踊兜，但在不同的場景下有不同的用途：
Semaphore主要用于控制對資源的訪問竿滨，限制并發(fā)線程的數(shù)量。
Condition主要用于線程之間的協(xié)調(diào)捏境，可以通過await()和signal()等方法實現(xiàn)線程的等待和喚醒于游。
Semaphore的適用場景：
Semaphore在以下場景中特別有用：
- 控制對有限資源的并發(fā)訪問，如數(shù)據(jù)庫連接池垫言、線程池等贰剥。
- 限制同時執(zhí)行某個操作的線程數(shù)量，如限流和限制并發(fā)請求等筷频。
- 在生產(chǎn)者-消費者模式中平衡生產(chǎn)者和消費者之間的速度差異蚌成。
方法四: 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）如此循環(huán)
c2.signal();
c1.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}).start();
try {
//確保t1已經(jīng)阻塞
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）如此循環(huán)
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();
}
