关于Java OutputStream 线程安全问题

今天偶尔发现java的输出流的线程安全问题

先看代码吧

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Random;
import java.util.concurrent.TimeUnit;


public class TestFileWrite {

	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		File f = new File("a"+System.currentTimeMillis());
		f.createNewFile();
		java.util.concurrent.CountDownLatch cwl = new java.util.concurrent.CountDownLatch(2);
		FileOutputStream fos = new FileOutputStream(f);
		new Thread(new WriteThread(cwl,fos,"bb")).start();
		new Thread(new WriteThread(cwl,fos,"aaasdfasfd")).start();
		cwl.countDown();
		cwl.countDown();
		TimeUnit.SECONDS.sleep(1);
		fos.flush();
		FileInputStream f1 = new FileInputStream(f);
		byte[] bytearray = new byte[1024];
		int n = f1.read(bytearray);
		f1.close();
		System.out.println(new String(bytearray,0,n));
	}

}

class WriteThread implements Runnable{

	OutputStream os = null;
	String fSpe = null;
	java.util.concurrent.CountDownLatch cwl;
	public WriteThread(java.util.concurrent.CountDownLatch cwl,OutputStream os, String fSpe) {
		super();
		this.cwl = cwl;
		this.os = os;
		this.fSpe = fSpe;
	}


	@Override
	public void run() {
//		for(int i=0;i<10;i++)
//		{
			try {
				cwl.await();
				os.write((fSpe+"\r\n").getBytes());
//				TimeUnit.SECONDS.sleep(new Random().nextInt(10));
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
//		}
		
	}
}

这里的输出结果很有意思，会相互覆盖，偶尔输出

aaasdfasfd

有时候输出

bb
dfasfd

输出第二种是因为第一bb \r\n把第一个字符串给覆盖掉了

观察Filetputtream的代码，发现很有意思，整个类是非线程安全的，不过在类的注释上没有标记这一点，最底层的写入是调用本地方法

 private native void writeBytes(byte b[], int off, int len, boolean append)

此处的相互覆盖应该是底层没有对并发进行处理，导致两个线程同时在字节流的同一位置进行写入，应该还会有更奇怪的输出

ab

dfasfd

不过这种输出的重现几率很小，理论上应该存在

再观察DataOutputStream 发现只有write(byte b[]）会加锁，其他时候不会加锁，不知到为何，难道是为了提升性能故意把锁去掉了？