引言
JDK中提供了自增運算符++，自減運算符--。這兩個操作符各有兩種使用方式：前綴式（++ a,--a），后綴式（a++，a--）。可能說到這里，說不得有讀者就會吐槽說，前后綴式都挺簡單的，前綴式不就是先進行+1（或-1），然后再使用該值參與運算嘛，后綴式則相反。有必要長篇大論嗎？
前后綴式的區別確實是這樣，最起碼表面上理解起來是這樣，但是更深入的理解就不是這么簡單了，甚至嚴重影響到你的程序的正確性。不信，接下去看吧！
1. 前綴式 與 后綴式的真正區別
在Java中，運算是從左往右計算的，並且按照運算符的優先級，逐一計算出表達式的值，並用這個值參與下一個表達式的運算，如：1+2+3，其實是先計算出1+2表達式的值為3，再參與下一個表達式的運算(1+2)+3，即3+3。再如判斷if(a+2==3)。如此類推。
a++是一個表達式 ，那么a++就會有一個表達式的計算結果，這個計算結果就是a的舊值（加1前的值）。相對的，++a表達式的計算結果a加1后的值。所以，自增的前綴形式與后綴形式的本質區別是：表達式的值（運算結果） 是加1前的變量的值還是加1后的變量的值（自減也是如此）。並不是先加1 與 后加1的區別，或者說，前后綴形式都是先加1（減1）的，才得到表達式的值，再參與下一步運算。因為這是一個表達式，必須先計算完表達式的運算，最后才會得到表達式的值
我們來看一個面試經常遇到的問題：
int a = 5;
a = a++;
//此時a的值是多少？
有猜到a的值嗎？我們用上面所學到的分析一下：a=a++可以理解成以下幾個步驟：
1> 計算a自加1，即 a=a+1
2> 計算表達式的值，因為這是后綴形式，所以a++表達式的值就是加1前a的值(值為5)；
3> 將表達式的值賦值給a，即a=5。
所以最后a的值是5。
同理，如果改成a = ++a;，則a的值是6。這是因為++a表達式的值是加1后的a，即為6。
2. 自增自減是包含兩個兩個操作，不是線程安全的
自增、自減運算符本質上不是一個計算操作，而是兩個計算操作。以a++為例，這個運算將會編譯器解析成：a=a+1，即包含兩個單目運算符（+、=）,一個單目運算符的計算操作可以看作是一個原子性操作。a++的步驟可以描述成 ：1> 先取a加1，將結果存儲在臨時空間；2>將結果賦給a。所以，自增自減運算符包含兩個操作：一個加1（減1）的操作和一個賦值的操作
這個原理好像對我的編程沒有用吧？不是的，在單線程的環境下，你可以不管這個細節。但在多線程的情況下，你就得時刻牢記這個細節了。要知道，自增自減不是原子性操作，也就是說不是線程安全的運算。因此，在多線程下，如果你要對共享變量實現自增自減操作，就要加鎖，或者使用JDK提供的原子操作類（如AtomincInteger，AtomicLong等）提供的原子性自增自減方。
來看個例子，驗證一下。下面的例子提供三個靜態變量（一個是原子操作類），創建了10個線程，每個線程都對這三個變量以不同的方式進行加1操作,並循環1000次。
public class MyTest {
static int a = 0;
static int b = 0;
//原子性操作類
static AtomicInteger atomicInt = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {//創建10個線程
Thread t = new Thread() {
@Override
public void run() {
for (int j = 0; j < 1000; j++) {//計算1000次
a = a + 1;
b++;
atomicInt.incrementAndGet();//自增的原子性方法
}
}
};
t.start();
}
// 判斷當前的活動線程是不是只有main線程，以確保10個計算線程執行完成。
while (Thread.activeCount() > 1) {
Thread.sleep(1000);
}
System.out.println("a=a+1在多線程下的結果是：" + a);
System.out.println("b++在多線程下的結果是：" + b);
System.out.println("原子操作類AtomicInteger在多線程下的結果是：" + atomicInt.get());
}
}
運行結果：
a=a+1在多線程下的結果是：8883
b++在多線程下的結果是：8974
原子操作類AtomicInteger在多線程下的結果是：10000
從運行的結果可以看出，a=a+1、b++不是線程安全的，沒有計算出正確的結果10000。也就是說這兩個表達式都不是原子性操作。事實上，它們都包含了兩個計算操作。
3. 由 a+++b 表達式引起的思考
看到這個表達式，真的很讓人疑惑：編譯器是怎么解析的，是解析成
a++ + b
還是
a+ ++b
真糾結，干脆直接在編譯器上跑一趟，看看結果吧！
int a = 5;
int b = 5;
int c=a+++b;
System.out.println("a的值是: "+a);
System.out.println("b的值是: "+b);
運行結果：
a的值是: 6
b的值是: 5
從結果可以確認，a+++b 其實是解析成了 a++ +b，為什么要這樣結合呢？其實有兩點原因：
- Java中的運算是從左往右進行的；
- java編譯器有一種規則——貪心規則。也就是說，編譯器會盡可能多地結合有效的符號。
那么，a+++b這樣的結合方式就可以解釋了
但是這種結合是：盡可能多的結合，而不管這樣的結合是否合法。如：
a--b
會被編譯器解析成
a-- b
盡管這是不合法，但編譯器還是這樣處理了，這就導致編譯不通過，產生編譯錯誤。
編譯器為什么要采用貪心規則呢？
從上面的分析來看，貪心規則在編程中也不好利用。那么，貪心規則的主要目的是為了什么？
貪心規則的主要目的就是為了分析String字符串，看看下面的例子就會明白：
String s = "\17";
System.out.println("\\17 轉義字符的值是："+s+" 長度是："+s.length());
s = "\171";
System.out.println("\\171 轉義字符的值是："+s+" 長度是："+s.length());
s = "\1717";
System.out.println("\\1717 轉義字符的值是："+s+" 長度是："+s.length());
s = "\17178";
System.out.println("\\17178 轉義字符的值是："+s+" 長度是："+s.length());
運行結果：
\17 轉義字符的值是： 長度是：1
\171 轉義字符的值是：y 長度是：1
\1717 轉義字符的值是：y7 長度是：2
\17178 轉義字符的值是：y78 長度是：3
“\17” 經轉義得到一個特殊字符 “” 。而“\171” 轉義后也得到一個字符 “y”。但 “\1717”、“\17178” 得到的字符串大於1，不再是一個字符，分別是 “y7”、“y78”。
也就是說,“\1717” 字符串只轉義了“\171” 部分，再鏈接 “7” 部分。“\17178” 字符串只轉義了 “\171” 部分,再連接 “78”。
那為什么 “\171” 為什么不轉義 ”\17“ 部分，再鏈接 ”1“ 呢，而是作為一個整體進行轉義的字符串呢？
這就是 ”貪心規則“ 所決定的。八進制的轉義字符的取值范圍是 \0~\377。所以解析 ”\171“ 字符串時，編譯器盡可能多地結合字符成一個轉移字符，”\171“ 還在取值范圍內，所以就是一個字符。但 ”\1718” 字符串，最多結合前4個字符成一個有效的轉義字符 “\171”，而“\1717” 已經超出取值范圍，不是有效字符，所以最后解析成 “\171” + "7" 的結果。“17178” 也是如此。
總結：
- 編譯器在分析字符時，會盡可能多地結合成有效字符，但有可能會出現語法錯誤。
- 貪心規則是有用的，特別編譯器是對轉義字符的處理。