System.out.println 的多線程並發問題

假設println函數的參數為常量則不會出現線程並發問題，可是假設參數為表達式形式。則JVM在運行println函數的時候會分為幾步來運行，從而造成並發問題。

例如以下樣例所看到的：

package xiaoye.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;

public class Test
{
	public static void main(String[] args)
	{
		ExecutorService pool = Executors.newFixedThreadPool(2);
		Runnable t1 = new MyRunnable("張三", 2000);
		Runnable t2 = new MyRunnable("李四", 3600);
		Runnable t3 = new MyRunnable("王五", 2700);
		Runnable t4 = new MyRunnable("老張", 600);
		Runnable t5 = new MyRunnable("老牛", 1300);
		Runnable t6 = new MyRunnable("老朱", 800);
		//運行各個線程
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		pool.execute(t5);
		pool.execute(t6);
		//關閉線程池
		pool.shutdown();
	}
}

class MyRunnable implements Runnable
{
	private static AtomicLong aLong = new AtomicLong(10000); //原子量。每一個線程都能夠自由操作
	private String name; //操作人
	private int data; //操作數

	MyRunnable(String name, int data)
	{
		this.name = name;
		this.data = data;
	}
	public void run()
	{
		Thread.yield();
		System.out.println(name + "運行了" + data + "。當前剩余金額：" + aLong.addAndGet(data));
	}
}

經過多次運行，當中一次結果例如以下：
        李四運行了3600，當前剩余金額：15600
        王五運行了2700，當前剩余金額：18300
        老張運行了600。當前剩余金額：18900
        老牛運行了1300，當前剩余金額：20200
        老朱運行了800。當前剩余金額：21000
        張三運行了2000。當前剩余金額：12000

對於 

System.out.println(name + "運行了" + data + "，當前剩余金額：" + aLong.addAndGet(data));

經過反編譯后得到例如以下實際代碼：

System.out.println((new StringBuilder(String.valueOf(name))).append("運行了").append(data).append("，當前剩余金額：").append(aLong.addAndGet(data)).toString());

而對於System.out.println() 方法，它的運行代碼例如以下：

    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

所以。輸出過程須要經過兩個步驟，轉化字符串和同步輸出。

實際上的運行過程是： 張三——李四——王五——老張——老牛——老朱，而實際上輸出 張三 卻是稱為最后一個輸出的。這是由於 張三 在或的鎖之前被打斷了。

假設我們想要輸出正確的運行順序，能夠加一個顯示鎖：

package xiaoye.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(2);
		Lock lock = new ReentrantLock(false);
		Runnable t1 = new MyRunnable("張三", 2000, lock);
		Runnable t2 = new MyRunnable("李四", 3600, lock);
		Runnable t3 = new MyRunnable("王五", 2700, lock);
		Runnable t4 = new MyRunnable("老張", 600, lock);
		Runnable t5 = new MyRunnable("老牛", 1300, lock);
		Runnable t6 = new MyRunnable("老朱", 800, lock);
		// 運行各個線程
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		pool.execute(t5);
		pool.execute(t6);
		// 關閉線程池
		pool.shutdown();
	}
}

class MyRunnable implements Runnable {
	private static AtomicLong aLong = new AtomicLong(10000); // 原子量，每一個線程都能夠自由操作
	private Lock lock;
	private String name; // 操作人
	private int data; // 操作數

	MyRunnable(String name, int data, Lock lock) {
		this.name = name;
		this.data = data;
		this.lock = lock;
	}

	public void run() {
		lock.lock();
		System.out.println(name + "運行了" + data + "，當前剩余金額："
				+ aLong.addAndGet(data));
		lock.unlock();
	}
}

這樣，不管怎樣執行，程序的輸出順序和操作的執行順序都保持一致。