引言
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” 也是如此。
总结
- 编译器在分析字符时，会尽可能多地结合成有效字符，但有可能会出现语法错误。
- 贪心规则是有用的，特别编译器是对转义字符的处理。
作者：jinggod
出处：http://www.cnblogs.com/jinggod/p/8424808.html