關於執行緒的快取重新整理
今天又是摸魚的一天，在群裡閒聊的時候突然有位群友題了個問題：
群友們反應很快，一下子就解決了沒有加關鍵字volatile，不能保證可見性。所以迴圈執行緒中的kaiguan變數一直讀取的是執行緒快取中的值，而執行緒快取的值一直無法讀取到主記憶體中的值。
當然這個問題難不倒這位提問的群友，所以他又提問了。
除了加volatile之外，還有沒有其他方式？
正好閒著無聊，我便開始試著解決這個問題。
public class test2 {
private static boolean kaiguan =true;
private static void go(){
new Thread(()->{
while (kaiguan){
}
System.out.println("事情做完了");
}).start();
new Thread(()->{
try {
Thread.sleep(1000*3);
kaiguan=false;
}catch (InterruptedException e){
e.printStackTrace();
}
}).start();
}
public static void main(String[] args) {
go();
}
}
首先我問了ChatGPT
如果不使用 volatile 關鍵字，也可以使用其他的多執行緒機制來保證可見性，例如使用 AtomicBoolean 類，這個類提供了 get() 和 set() 方法，可以保證操作的原子性和可見性。
修改後的程式碼如下所示：
private static AtomicBoolean kaiguan = new AtomicBoolean(true);
private static void go() {
new Thread(() -> {
while (kaiguan.get()) {
Thread.yield(); // 或者使用Thread.sleep()，暫停執行緒一段時間
}
System.out.println("事情做完了");
}).start();
new Thread(() -> {
try {
Thread.sleep(1000 * 3);
kaiguan.set(false); // 設定kaiguan變數為false，退出迴圈
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
public static void main(String[] args) {
go();
}
在上述程式碼中，我們使用了 AtomicBoolean 類來代替原來的 boolean 型別的 kaiguan 變數，並在 while 迴圈中使用了 kaiguan.get() 方法來獲取 kaiguan 變數的值，從而保證可見性。在另一個執行緒中，我們使用 kaiguan.set(false) 方法將 kaiguan 變數設定為 false ，從而退出迴圈。
可以看到 除了使用volatile 來宣告變數，我們還可以用AtomicBoolean 來宣告kaiguan。同樣能保證可見性。
那如果不用AtomicBoolean宣告kaiguan呢？
我看到了下面這篇文章：
執行緒的快取何時重新整理？ - 簡書 (jianshu.com)
在Doug Lea大神的Concurrent Programming in Java一書中有這樣一個片段來描述synchronized這個關鍵字：
In essence, releasing a lock forces a flush of all writes from working memory employed by the thread, and acquiring a lock forces a (re)load of the values of accessible fields. While lock actions provide exclusion only for the operations performed within a synchronized method or block, these memory effects are defined to cover all fields used by the thread performing the action.
簡單翻譯一下：從本質上來說，當執行緒釋放一個鎖時會強制性的將工作記憶體中之前所有的寫操作都重新整理到主記憶體中去，而獲取一個鎖則會強制性的載入可存取到的值到執行緒工作記憶體中來。雖然鎖操作只對同步方法和同步程式碼塊這一塊起到作用，但是影響的卻是執行緒執行操作所使用的所有欄位。
也就是說我們可以用加鎖來解決執行緒重新整理這個問題。
所以我們可以手動加上System.out.println();來退出該回圈。
因為System.out.println();底層是加鎖的
public void println() {
newLine();
}
private void newLine() {
try {
synchronized (this) {
ensureOpen();
textOut.newLine();
textOut.flushBuffer();
charOut.flushBuffer();
if (autoFlush)
out.flush();
}
}
catch (InterruptedIOException x) {
Thread.currentThread().interrupt();
}
catch (IOException x) {
trouble = true;
}
}
我們在看看chatgpt的回答，既然裡面有提到yield()與sleep()，那麼我們就試試
Thread.yield();
與
Thread.sleep(0);
發現果然成功跳出迴圈，那麼yield()與sleep(0)到底發生了什麼導致快取重新整理呢？
沒錯就是上下文切換！
yield()與sleep(0)會導致上下文切換，從而導致快取失效，從而拉去主記憶體中的新值。
當然我們也可以直接使用Unsafe方法中的loadFence（）方法。
使用UnsafeFactory.getUnsafe().loadFence();也同樣可以跳出迴圈，因為loadFence: 可以保證在這個屏障之前的所有讀操作都已經完成。
Unsafe需要我們通過反射獲取，直接呼叫會報錯：
public static Unsafe getUnsafe() {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
在尋找其他答案的過程中我還發現final關鍵字同樣也有重新整理快取的作用
首先自定義一個類，將其中的num設定為final
public class TestTempOne {
final int num; //設為final；
TestTempOne(int num){
this.num=num;
}
}
private static void go(){
new Thread(()->{
while (kaiguan){
// new TestTempOne(0); //跳出迴圈
// new String("a"); //跳出迴圈
// new Integer(0); //死迴圈
// new Integer(129); //死迴圈
new Integer(100000000); //死迴圈
}
可以看到最終會跳出迴圈，但是有個問題Integer中value的值同樣也是final。但卻不能重新整理快取。而String則是一個final char陣列，也可以跳出迴圈。目前沒有找到答案，如果有大佬知道答案，請告知我一下！
總結：我目前知道的有六種：
1、使用volatile
2、使用synchronized或者Lock
3、使用AtomicBoolean
4、使用UnsafeFactory.getUnsafe().loadFence();
5、使用yield()與sleep()
6、final關鍵字