java線程管道

㈠ 如何在學習java過程中實現線程之間的通信

在java中,每個對象都有兩個池,鎖池(monitor)和等待池(waitset),每個對象又都有wait、notify、notifyAll方法,使用它們可以實現線程之間的通信,只是平時用的較少.

wait(): 使當前線程處於等待狀態,直到另外的線程調用notify或notifyAll將它喚醒

notify(): 喚醒該對象監聽的其中一個線程(規則取決於JVM廠商,FILO,FIFO,隨機…)

notifyAll(): 喚醒該對象監聽的所有線程

鎖池: 假設T1線程已經擁有了某個對象(注意:不是類)的鎖,而其它的線程想要調用該對象的synchronized方法(或者synchronized塊),由於這些線程在進入對象的synchronized方法之前都需要先獲得該對象的鎖的擁有權,但是該對象的鎖目前正被T1線程擁有,所以這些線程就進入了該對象的鎖池中.

等待池: 假設T1線程調用了某個對象的wait()方法,T1線程就會釋放該對象的鎖(因為wait()方法必須出現在synchronized中,這樣自然在執行wait()方法之前T1線程就已經擁有了該對象的鎖),同時T1線程進入到了該對象的等待池中.如果有其它線程調用了相同對象的notifyAll()方法,那麼處於該對象的等待池中的線程就會全部進入該對象的鎖池中,從新爭奪鎖的擁有權.如果另外的一個線程調用了相同對象的notify()方法,那麼僅僅有一個處於該對象的等待池中的線程(隨機)會進入該對象的鎖池.

java實現線程間通信的四種方式

1、synchronized同步：這種方式，本質上就是「共享內存」式的通信。多個線程需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。

2、while輪詢：其實就是多線程同時執行，會犧牲部分CPU性能。

3、wait/notify機制

4、管道通信：管道流主要用來實現兩個線程之間的二進制數據的傳播

㈡ java中線程池如何管理多個線程

ExecutorService threadPoll = Executors.newCachedThreadPool(); //創建線程池
threadPoll.execute(線程1);//執行線程一

線程池根據程序需求創建新線程的，需求多時，創建的就多，需求少時，JVM自己會慢慢的釋放掉多餘的線程

不需求程序員去做什麼,JVM自己會處理,程序員調用就行了..

㈢ java多線程,對象鎖是什麼概念

java線程:

1．線程中一些基本術語和概念

1.1線程的幾個狀態
初始化狀態
就緒狀態
運行狀態
阻塞狀態
終止狀態
1.2 Daemon線程
Daemon線程區別一般線程之處是：主程序一旦結束，Daemon線程就會結束。
1.3鎖的定義
為了協調多個並發運行的線程使用共享資源才引入了鎖的概念。
1.4死鎖
任何多線程應用程序都有死鎖風險。當一組線程中的每一個都在等待一個只
有該組中另一個線程才能引起的事件時，我們就說這組線程死鎖了。換一個說法
就是一組線程中的每一個成員都在等待別的成員佔有的資源時候，就可以說這組
線程進入了死鎖。死鎖的最簡單情形是：線程 A 持有對象 X 的獨占鎖，並且
在等待對象 Y 的鎖，而線程 B 持有對象 Y 的獨占鎖，卻在等待對象 X 的鎖。
除非有某種方法來打破對鎖的等待（Java 鎖定不支持這種方法），否則死鎖的線
程將永遠等下去。

1.5.Java對象關於鎖的幾個方法
1.5.1 wait方法
wait方法是java根對象Object含有的方法，表示等待獲取某個鎖。在wait方法進入前，會釋放相應的鎖，在wait方法返回時，會再次獲得某個鎖。
如果wait()方法不帶有參數，那隻有當持有該對象鎖的其他線程調用了notify或者notifyAll方法，才有可能再次獲得該對象的鎖。
如果wait()方法帶有參數，比如：wait(10)，那當持有該對象鎖的其他線程調用了notify或者notifyAll方法，或者指定時間已經過去了，才有可能再次獲得該對象的鎖。
參考 thread.lock.SleepAndWait
1.5.2 notify/notifyAll方法
這里我就不再說明了。哈哈，偷點懶。
1.5.3 yield方法
yield()會自動放棄CPU，有時比sleep更能提升性能。
1.6鎖對象(實例方法的鎖)
在同步代碼塊中使用鎖的時候，擔當鎖的對象可以是這個代碼所在對象本身或者一個單獨的對象擔任，但是一定要確保鎖對象不能為空。如果對一個null對象加鎖，會產生異常的。原則上不要選擇一個可能在鎖的作用域中會改變值的實例變數作為鎖對象。
鎖對象,一種是對象自己擔任，一種是定義一個普通的對象作為private property來擔任，另外一種是建立一個新的類，然後用該類的實例來擔任。
參考 :
thread.lock.UseSelfAsLock，使用對象自己做鎖對象
thread.lock.UseObjAsLock 使用一個實例對象作鎖對象
thread.lock.UseAFinalObjAsLock使用常量對象作為一個鎖對象
1.7類鎖
實例方法存在同步的問題，同樣，類方法也存在需要同步的情形。一般類方法的類鎖是一個static object來擔任的。當然也可以採用類本身的類對象來作為類鎖。
一個類的實例方法可以獲得該類實例鎖，還可以嘗試去訪問類方法，包含類同步方法，去獲得類鎖。
一個類的類方法，可以嘗試獲得類鎖，但是不可以嘗試直接獲得實例鎖。需要先生成一個實例，然後在申請獲得這個實例的實例鎖。
參考
thread.lock.UseStaticObjAsStaticLock 使用類的屬性對象作為類鎖。
thread.lock.UseClassAsStaticLock使用類的類對象作為類鎖

1.8.線程安全方法與線程不安全方法
如果一個對象的所有的public方法都是同步方法，也就是說是public方法是線程安全的，那該對象的private方法，在不考慮繼承的情況下，可以設置為不是線程安全的方法。
參考 thread.lock.SynMethrodAndNotSynMethrod

1.9類鎖和實例鎖混合使用
在實例方法中混合使用類鎖和實例鎖；可以根據前面說的那樣使用實例鎖和類鎖。
在類方法中混合使用類鎖和實例鎖，可以根據前面說的那樣使用類鎖，為了使用實例鎖，先得生成一個實例，然後實例鎖。
參考 thread.lock.StaticLockAndObjLock
1.10鎖的粒度問題。
為了解決對象鎖的粒度過粗，會導死鎖出現的可能性加大，鎖的粒度過細，會程序開發維護的工作加大。對於鎖的粒度大小，這完全要根據實際開發需要來考慮，很難有一個統一的標准。

1.11.讀寫鎖
一個讀寫鎖支持多個線程同時訪問一個對象，但是在同一時刻只有一個線程可以修改此對象，並且在訪問進行時不能修改。
有2種調度策略，一種是讀鎖優先，另外就是寫鎖優先。
參考 thread.lock.ReadWriteLock
1.12 volatile
在Java中設置變數值的操作，除了long和double類型的變數外都是原子操作，也就是說，對於變數值的簡單讀寫操作沒有必要進行同步。這在JVM 1.2之前，Java的內存模型實現總是從主存讀取變數，是不需要進行特別的注意的。而隨著JVM的成熟和優化，現在在多線程環境下volatile關鍵字的使用變得非常重要。在當前的Java內存模型下，線程可以把變數保存在本地內存（比如機器的寄存器）中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變數的值，而另外一個線程還繼續使用它在寄存器中的變數值的拷貝，造成數據的不一致。要解決這個問題，只需要像在本程序中的這樣，把該變數聲明為volatile（不穩定的）即可，這就指示JVM，這個變數是不穩定的，每次使用它都到主存中進行讀取。一般說來，多任務環境下各任務間共享的標志都應該加volatile修飾。

2．線程之間的通訊
在其他語言中，線程之間可以通過消息隊列，共享內存，管道等方式來實現
線程之間的通訊，但是java中可以不採用這樣方式，關注的是線程之間的同步。
只要保證相關方法運行的線程安全，信息共享是自然就可以顯現了。
2.1屏障
屏障就是這樣的一個等待點: 一組線程在這一點被同步，這些線程合並各自的結果或者運行到整體任務的下一階段。
參考：
thread.lock. BarrierUseExample
thread.lock.Barrier
2.2.鎖工具類
提供對線程鎖的獲取，釋放功能。展示了鎖的獲取釋放過程。可以作為一個工具類來使用。
參考：thread.lock. BusyFlag

2.3.條件變數
條件變數是POSIX線程模型提供的一種同步類型，和java中的等待通知機制類似。
雖然java中已經有了等待通知機制，但是為了減少在notify/notifyAll方法中
線程調度的開銷，把一些不需要激活的線程屏蔽出去，引入了條件變數。
Java中2個（多個）條件變數可以是同一個互斥體（鎖對象）。
參考：thread.lock.CondVar 條件變數類
常見的應用情形：
一個鎖控制多個信號通道（例如：多個變數），雖然可以採用簡單java等待通知機制，但是線程調度效率不高，而且線程可讀性也不是太好，這時候可以採用創建一個鎖對象(BusyFlag實例)，同時使用這個BusyFlag實例來創建多個條件變數(CondVar 實例)。
經常使用到CondVar類的地方是緩沖區管理，比如：管道操作之類的。先創建一個BusyFlag實例，然後創建CondVar 實例，用這個條件變數描述緩沖區是否為空，另外創建CondVar 實例作條件變數述緩沖區是否滿。
現實中，馬路的紅綠燈，就可以採用條件變數來描述。

3. Java線程調度
3.1 Java優先順序
java的優先順序別共有10種，加上虛擬機自己使用的優先順序別=0這種，總共11種。
大多數情況來說，java線程的優先順序設置越高（最高=10），那線程越優先運行。
3.2. 綠色線程
線程運行在虛擬機內，操作系統根本不知道這類線程的存在。
線程是由虛擬機調度的。
3.3 本地線程
線程是由運行虛擬機的操作系統完成的。
3.4 Windows本地線程
操作系統，完全能夠看得到虛擬機內的每一個線程，同時虛擬機的線程和操作系統的線程是一一對應的。Java的線程調度室由操作系統底層線程決定的。
在win32平台下，windows線程只有6個優先順序別。和java線程優先順序別對應如下：
Java線程優先順序 Windows 95/nt/2000線程優先順序
0 THREAD_ PRIORITY_IDLE
1(Thread.MIN_PRIORITY) THREAD_ PRIORITY_LOWEST
2 THREAD_ PRIORITY_LOWEST
3 THREAD_ PRIORITY_BELOW_NORMAL
4 THREAD_ PRIORITY_BELOW_NORMAL
5 (Thread.NORM_PRIORITY) THREAD_ PRIORITY _NORMAL
6 THREAD_ PRIORITY _ABOVE_NORMAL
7 THREAD_ PRIORITY _ABOVE_NORMA
8 THREAD_ PRIORITY _HIGHEST
9 THREAD_ PRIORITY _HIGHEST
10 (Thread.MAX_PRIORITY) THREAD_ PRIORITY _CRITICAL

3.5線程優先順序倒置與繼承
如果一個線程持有鎖(假設該線程名字=ThreadA,優先順序別=5)，另外一個線程(假設該線程名字=ThreadB,優先順序別=7),現在該線程(ThreadA)處於運行狀態，但是線程ThreadB申請需要持有ThreadA所獲得的鎖，這時候，為了避免死鎖，線程A提高其運行的優先順序別（提高到ThreadB的優先順序別=7）,而線程ThreadB為了等待獲得鎖，降低線程優先順序別(降低到ThreadA原來的優先順序別=5).
上述的這種情況，對於ThreadA,繼承了ThreadB的優先順序別，這成為優先順序別的繼承；對於ThreadB暫時降低了優先順序別，成為優先順序別的倒置。
當然，一旦線程ThreadA持有的鎖釋放了，其優先順序別也會回到原來的優先順序別（優先順序別=5）。線程ThreadB獲得了相應的鎖，那優先順序別也會恢復到與原來的值(優先順序別=7)。

3.6循環調度
具有同樣優先順序的線程相互搶占成為循環調度。

4.線程池
創建一個線程也是需要一定代價的,為了降低這個代價，採用了和普通對象池的思想建立線程池，以供系統使用。
線程消耗包括內存和其它系統資源在內的大量資源。除了 Thread 對象所需的內存之外，每個線程都需要兩個可能很大的執行調用堆棧。除此以外，JVM 可能會為每個 Java 線程創建一個本機線程，這些本機線程將消耗額外的系統資源。最後，雖然線程之間切換的調度開銷很小，但如果有很多線程，環境切換也可能嚴重地影響程序的性能。
使用線程池的方式是，先建立對象池，然後申請使用線程，程序線程運行，運行完畢，把線程返回線程池。
使用線程池的風險：同步錯誤和死鎖，與池有關的死鎖、資源不足和線程泄漏。
大家有空可以研究一下tomcat的線程池實現原理思想。
實際上是tomcat已經在從線程池的使用線程時候加上了事件處理機制。
個人認為，線程池之類的實現，一般不要自己實現，因為自己實現主要是穩定性等方面可能作的不夠好。
可以參考 apache的jakarta-tomcat-5.5.6的相關代碼，具體是：
jakarta-tomcat-connectors\util\java\org\apache\tomcat\util\threads的相關代碼

5工作隊列
使用工作隊列的好處是不象直接使用線程池那樣，當線城池中沒有線程可以使用的時
候，使用者需要處於等待狀態，不能進行其他任務的處理。
工作隊列的工作原理是：
採用後台線程處理方式，客戶端把任務提交給工作隊列，工作隊列有一組內部可以工作線程，這些工作線程從工作隊列中取出任務運行，一個任務完成後，就從隊列獲取下一個任務進行處理。當工作隊列中沒有任務可以處理時候，工作線程就處於等待狀態，直到獲得新的任務時候，才進行新的處理。

㈣ java 兩個子線程怎麼傳值線程傳值

用管道可能你不太熟悉，也可以用一個折中辦法：這兩個線程如果出自一個母類體生成並.start的話，可以在母類體中設置一個全局的數組變數，把母類體當成傳輸中介，就可以了。一定能傳到。希望能對你有幫助。

㈤ Java 中利用管道實現線程間的通訊

在Java 語言中 提供了各種各樣的輸入輸出流（stream） 使我們能夠很方便的對數據進行操作 其中 管道（pipe）流是一種特殊的流 用於在不同線程（threads）間直接傳送數據 一個線程發送數據到輸出管道 另一個線程從輸入管道中讀數據 通過使用管道 實現不同線程間的通訊 無需求助於類似臨時文件之類的東西 本文在簡要介紹管道的基本概念後 將以一個具體的實例pipeapp加以詳細說明 ．管道的創建與使用Java提供了兩個特殊的專門的類專門用於處理管道 它們就是pipedinputstream類和pipeoutputstream類 Pipedinputstream代表了數據在管道中的輸出端 也就是線程向管道讀數據的一端 pipeoutputstream代表了數據在管道中的輸入端 也就是線程向管道寫數據的一端 這兩個類一起使用可以提供數據的管道流 為了創建一個管道流 我們必須首先創建一個pipeoutstream對象 然後 創建pipeinputstream對象 實例如下 pipeout= new pipedyoutstream();pipein= new pipedputsteam(pipepout);一旦創建了一個管道後 就可以象操作文件一樣對管道進行數據的讀寫 ．演示程序 pipeapp應用程序由三個程序組成 主線程（pipeapp Java）及由主線程啟動的兩個二級線程（ythread Java和zthread Java） 它們使用管道來處理數據 程序從一個內容為一行一行 x 字母的 input txt 文件中讀取數據 使用管道傳輸數據 第一次是利用線程ythread將數據 x 轉換為 y 最後利用線程zthread將 y 轉換為 z 之後 程序在屏幕上顯示修改後的數據 主線程 （pipeapp Java）在main()方法中 程序首先創建一個應用對象 pipeapp pipeapp=new pipeapp();由於程序中流操作都需要使用IOException異常處理 所以設置了一個try塊 在try中 為了從源文件中讀取數據 程序為 input txt 文件創建了一個輸入流Xfileln :fileinputstream xfileln= new fileinputstream( input txt );新的輸入流傳遞給changetoy()方法 讓線程ythread能讀取該文件 inputstream ylnpipe =pipeapp changetoy(xfileln);changetoy()方法創建將輸入數據 x 改變到 y 的線程ythread 並返回該線程的輸入管道 inputstream zlnpipe = pipeapp changetoz(ylnpipe);changetoz()方法啟動將數據從 y 改變到 z 的線程zehread 主程序將使用從changetoz()返回的輸入管道 得到以修改的數據 然後 程序將管道輸入流定位到datainputstream對象 使程序能夠使用readline()方法讀取數據 datainputstream inputstream = new datainputstream(zlnpiepe);創建了輸入流以後 程序就可以以行一行的讀取數據病顯示在屏幕上 String str= inputstream readline();While(str!=null){system out println(str);str=inputstream readline();} 顯示完成之後 程序關閉輸入流 inputstream close();changetoy()方法 changetoy()方法首先通過傳遞一個參數inputstream給datainputstream對象來定位資源的輸入流 使程序能使用readline()方法從流中讀取數據 datainputstream xfileln =new datainutstream(inputstream) 然後 changetoy()創建輸出管道和輸入管道 pipeoutstream pipeout = new pipeoutputstream();pipeinputstream pipeln = new pipedinputsteam(pipeout); 為了能夠使用println()方法輸出修改的後的文本行到管道 程序將輸出管道定位到printstream對象 printstream printstream = new printstream(pipeout);現在 程序可以創建將數據從x改變到y的線程 該線程是ythread類的一個對象 他傳遞兩個參數 輸入文件（xfileln）和輸出管道（調用printstream）ythread ythread =new thread(xfileln printstream);之後 程序啟動線程 changetoz（）方法changetoz()方法與changetoy()方法很相似 他從changetoy()返回的輸入流開始 datainputstream yfileln= new datainputstream(inputstream);程序創建一個新的管道 pipedoutstream pipeout = new pipedoutputstream();pipedinputstream pipeln = new pipedinputsream(pipeout ); 該線程通過這個新的管道發出修改後的數據（輸入流pipeln ）給主程序 源程序如下 ////pipeapp Java pipeapp的主應用程序//import Java io *class pipeapp{public static void main(string[] args){pipeapp pipeapp=new pipeapp();try{fileinputstream xfile =new fileinputstream( input txt );inputstream ylnpipe = pipeapp changetoy(xfileln);inputstream zlnpipe=pipeapp changetoz(ylnpipe);system out println();system out println( here are the results );system out pringln();datainputstream inputstream = nes datainputstream(zlnpipe);string str = inputstream readline();while (str!=null){system out println(str);str=inputstream readline();}inputstream close();}catch(exception e){system out println(e tostring());}}public inputstream changetoy(inputstream inputstream){try{datainputstream pipeout = new datainputsteam(inputstream);pipedoutstream pipeout = new pipedoutputstream();pipedlnsteam pipeln = new pipedlnputstream(pipeout);printstream printstream = new printstream(pipeout);ythread ythread = new ythread(xfileln printstream);ythread start();return pipeln;}catch(exeption e){system out println(x tostring());}return null;}public inputstream changetoz(inputstream inputsteam){try{datainputstream yfileln = new datainputstream(inputstream);pipeoutputstream pipeln = new pipedinputstream(pipeout );printrstream printstream = new printsteam(pipeout );zthread zthread = new zthread(yfileln printstream );zthread start();return pipeln ;}catch(exception e){system out println(e tostring());}return null;}} Ythread類和Zthread類由於ythread類與zthread類基本一樣 在此僅以ythread為例加以說明 Ythread的構造器接收兩個參數 輸入的文件和第一個管道的輸出端 構造器存儲這兩個參數作為類的數據成員 Ythread(datainputstream xfileln pringstream printstream){this xfileln = xfileln;this printstream = printstream;} 線程通過run()方法來處理數據 首先讀取一行數據 確保xstring不為空的情況下循環執行 string xstring = xfileln readline();每讀一行數據 完成一次轉換string ystring = xstring replace( x y );然後將修改後的數據輸出到管道的輸出端 prinstream prinrln(ystring);為了確保所有緩沖區的數據完全進入管道的輸出端 pringstram flush();循環完成後 線程關閉管道輸出流 pringstram close();ythread類的源程序如下 //ythread Java//import Java io *;class ythread exteads thread{datainputstream xfileln;pringstream printstream;ythread(datainputstream xfileln pringstream printstream){this xfileln = xfileln;this printstream = printstream;}public void run(){try{string xstring = xfileln readline();while(xstring!=null){string ystring= xstring replace( x y );printstream pringln(ystring);printstream flush();xstring= xfileln readline();}printstream close();}catch{ioexception e}{system out println(e tostring());}}} pipeapp應用程序使用microsoft visual j++ 編譯 lishixin/Article/program/Java/gj/201311/27508

㈥ java 管道流

管道流實際上就是整行的讀取和寫入，不用每個位元組每個位元組的讀取和寫入
讀寫是兩個不同的分支，通常都是分開單獨使用的。
可以通過BufferedReader 流的形式進行流緩存，之後通過readLine方法獲取到緩存的內容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此時獲取到的bre就是整個文件的緩存流
while ((str = bre.readLine())!= null) // 判斷最後一行不存在，為空結束循環
{
System.out.println(str);//原樣輸出讀到的內容
}；
備注一： 流用完之後必須close掉，如上面的就應該是：bre.close()，否則bre流會一直存在，直到程序運行結束。
可以通過「FileOutputStream」創建文件實例，之後過「OutputStreamWriter」流的形式進行存儲，舉例：
OutputStreamWriter pw = null;//定義一個流
pw = new OutputStreamWriter(new FileOutputStream(「D:/test.txt」),"GBK");//確認流的輸出文件和編碼格式，此過程創建了「test.txt」實例
pw.write("我是要寫入到記事本文件的內容");//將要寫入文件的內容，可以多次write
pw.close();//關閉流
備注二：文件流用完之後必須及時通過close方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。

㈦ Java的線程在項目中一般會有什麼具體的應用

java線程在項目中的應用場景如下：

場景一:一個業務邏輯有很多次的循環，每次循環之間沒有影響，比如驗證1萬條url路徑是否存在，正常情況要循環1萬次，逐個去驗證每一條URL，這樣效率會很低，假設驗證一條需要1分鍾，總共就需要1萬分鍾，有點恐怖。這時可以用多線程，將1萬條URL分成50等份，開50個線程，沒個線程只需驗證200條，這樣所有的線程執行完是遠小於1萬分鍾的。
場景二:需要知道一個任務的執行進度，比如我們常看到的進度條，實現方式可以是在任務中加入一個整型屬性變數(這樣不同方法可以共享)，任務執行一定程度就給變數值加1，另外開一個線程按時間間隔不斷去訪問這個變數，並反饋給用戶。
總之使用多線程就是為了充分利用cpu的資源，提高程序執行效率，當你發現一個業務邏輯執行效率特別低，耗時特別長，就可以考慮使用多線程。不過CPU執行哪個線程的時間和順序是不確定的，即使設置了線程的優先順序，因此使用多線程的風險也是比較大的，會出現很多預料不到的問題，一定要多熟悉概念，多構造不同的場景去測試才能夠掌握!

㈧ java的管道流，兩個線程，輸出流輸出數據，輸入流就是不讀取

線程啟動要調start方法, 你調run方法相當於只有一個主線程, 因此輸出一部分數據後線程就被就阻塞了, 所以只要將
new Thread(ts).run();
new Thread(tr).run();
改成
new Thread(ts).start();
new Thread(tr).start();
就行了

㈨ java線程傳值的問題

把那些對象類型的變數定義為 static 類型

或者，有一個線程間傳值得方法，管道技術，不知道你有沒有接觸這方面的內容：
Java中利用管道實現線程間的通訊
管道（pipe）流是一種特殊的流，用於在不同線程（threads）間直接傳送數據。一個線程發送數據到輸出管道，另一個線程從輸入管道中讀數據。通過使用管道，實現不同線程間的通訊。
你可以搜艘縣官的內容，相信對你有幫助

㈩ 編寫一個利用管道流，實現線程之間的通信，實現文件傳輸功能Java程序

importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PipedInputStream;
importjava.io.PipedOutputStream;
importjava.io.PrintWriter;
publicclassDay10A{
	privateBufferedReaderbr;//字元效率讀取流
	privateBufferedWriterbw;//字元效率寫出流
	privatePipedInputStreampis;//管道讀取流
	privatePipedOutputStreampos;//管道輸出流,
	privatebyte[]readBytes;//讀取緩沖區
	privatebyte[]writeBytes;//寫出緩沖區
	privateStringpath="C:\Users\Administrator\Desktop";
	privateFilefile=null;
	privateFileOutputStreamfos=null;

	Day10A(){
		writeBytes=newbyte[1024];
		file=newFile(path,"測試.txt");
		try{
			if(!file.exists()){
				file.createNewFile();
				fos=newFileOutputStream(file);
			}else{
				fos=newFileOutputStream(file,true);
			}
			br=newBufferedReader(newInputStreamReader(System.in));
			bw=newBufferedWriter(newPrintWriter(fos));
			pis=newPipedInputStream();
			pos=newPipedOutputStream();
			pis.connect(pos);
		}catch(IOExceptione){
			e.printStackTrace();
		}
	}
	publicstaticvoidmain(String[]args){
		Day10Ad=newDay10A();
		d.readFunction();
		d.writerFunction();
	}
	privatevoidreadFunction(){
		newThread(newRunnable(){
			publicvoidrun(){
				while(true){
					try{
						for(Stringstr=br.readLine();!str.contentEquals("over");str=br.readLine()){
							readBytes=str.getBytes();
							pos.write(readBytes);
						}
					}catch(Exceptione){
					}
					break;
				}
				try{
					pos.close();
				}catch(IOExceptione){
					e.printStackTrace();
				}
			}
		}).start();
	}
	privatevoidwriterFunction(){
		newThread(newRunnable(){
			@Override
			publicvoidrun(){
				try{
					Stringstr="";
					for(intlen=pis.read(writeBytes);len!=-1;len=pis.read(writeBytes)){
						str=newString(writeBytes,0,len);
						bw.write(str+"
");
						bw.flush();
					}
				}catch(Exceptione){
				}
			}
		}).start();
	}
}