A. Java中如何實現父線程如何獲得子線程數據
建立一個類
繼承Thread或者Runnable介面就自己看著辦了
然後在run方法法裡面
while(true)
{
××××××
//寫上重畫的代碼
Thread.sleep(1000);
}
B. java 如何獲得線程池中正在執行的線程數
java中線程池的監控可以檢測到正在執行的線程數。
通過線程池提供的參數進行監控。線程池裡有一些屬性在監控線程池的時候可以使用
taskCount：線程池需要執行的任務數量。
completedTaskCount：線程池在運行過程中已完成的任務數量。小於或等於taskCount。
largestPoolSize：線程池曾經創建過的最大線程數量。通過這個數據可以知道線程池是否滿過。如等於線程池的最大大小，則表示線程池曾經滿了。
getPoolSize:線程池的線程數量。如果線程池不銷毀的話，池裡的線程不會自動銷毀，所以這個大小隻增不+
getActiveCount：獲取活動的線程數。
通過擴展線程池進行監控。通過繼承線程池並重寫線程池的beforeExecute，afterExecute和terminated方法，我們可以在任務執行前，執行後和線程池關閉前干一些事情。如監控任務的平均執行時間，最大執行時間和最小執行時間等。這幾個方法在線程池裡是空方法。如：
protected
void
beforeExecute(Thread
t,
Runnable
r)
{
}
C. 急求：java 如何獲得線程運算的結果
在main方法中創建一個數組。
所有線程類的構造方法都需要一個數組做參數。線程體結束時給數組中的某個元素賦值。
public void run() {
......
a[i] = ......;
}
main方法中等待所有線程結束後列印數組。
t1.join();
D. java獲得當前線程有兩種方法，第一種是Thread.currentThread();誰知道另外一種
另外一種是實現Runnable介面，implements Runnable
這種方法有兩個好處是
(1)適合多個相同程序代碼的線程去處理同一資源的情況，把虛擬CPU（線程）同程序的代碼，數據有效的分離，較好地體現了面向對象的設計思想。
(2)可以避免由於Java的單繼承特性帶來的局限。經常碰到這樣一種情況，即當要將已經繼承了某一個類的子類放入多線程中，由於一個類不能同時有兩個父類，所以不能用繼承Thread類的方式，那麼，這個類就只能採用實現Runnable介面的方式了。
E. Java回調以及如何獲取線程的執行結果
軟體模塊之間存在調用的介面，從調用方式來看，有同步調用、回調、非同步調用這三種方式：
同步調用是是一種阻塞式調用，調用方要等待被調用方執行完畢返回後才能獲取調用的執行結果，是一種單向調用。
回調是一種雙向調用，調用方在執行被調用方後，被調用方會調用被調用方的介面；
非同步調用是一種類似消息或者事件的機制，介面在收到某個消息或發生某事件時，會主動通知客戶方，通常使用回調來實現非同步調用。
Java回調的必須要素：
1.僱主類必須有可以被觀察者調用的方法A；
2.觀察者必須持有可以調用A的對象的引用。
在實際工作中，我們通常將方法A以interface或者內部類的形式來實現，然後把包含有A的類的對象引用傳遞到觀察者中。
Java中的線程的返回值是void，並且是一個非同步執行流，所以我們沒有直接的方法來獲取線程執行後的結果，即不能直接知道線程何時結束，以及合適去獲取線程執行任務後的結果。由於回調的存在，我們可以在線程中以回調的方式通知線程的調用者線程的結束時間，並可以將任務的結果通過回調回送到調用者中。
F. java怎麼在線程裡面獲取數據
import java.io.*;
class DownThread extends Thread {
//定義位元組數組（取水的竹筒）的長度
private final int BUFF_LEN = 32;
//定義讀取的起始點
private long start;
//定義讀取的結束點
private long end;
//讀取文件對應的輸入流
private InputStream is;
//將讀取到的位元組輸出到raf中
private RandomAccessFile raf;
//構造器，傳入輸入流，輸出流和讀取起始點、結束點
public DownThread(long start, long end, InputStream is, RandomAccessFile raf) {
//輸出該線程負責讀取的位元組位置
System.out.println(start + "---->" + end);
this.start = start;
this.end = end;
this.is = is;
this.raf = raf;
}
public void run() {
try {
is.skip(start);
raf.seek(start);
//定義讀取輸入流內容的的緩存數組（竹筒）
byte[] buff = new byte[BUFF_LEN];
//本線程負責讀取文件的大小
long contentLen = end - start;
//定義最多需要讀取幾次就可以完成本線程的讀取
long times = contentLen / BUFF_LEN + 4;
//實際讀取的位元組數
int hasRead = 0;
for (int i = 0; i < times; i++) {
hasRead = is.read(buff);
//如果讀取的位元組數小於0，則退出循環！
if (hasRead < 0) {
break;
}
raf.write(buff, 0, hasRead);
}
} catch (Exception ex) {
ex.printStackTrace();
}
//使用finally塊來關閉當前線程的輸入流、輸出流
finally {
try {
if (is != null) {
is.close();
}
if (raf != null) {
raf.close();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
public class MutilDown {
public static void main(String[] args) {
final int DOWN_THREAD_NUM = 4;
final String OUT_FILE_NAME = "d:/勇敢的心.rmvb";
InputStream[] isArr = new InputStream[DOWN_THREAD_NUM];
RandomAccessFile[] outArr = new RandomAccessFile[DOWN_THREAD_NUM];
try {
isArr[0] = new FileInputStream("d:/勇敢的心.rmvb");
long fileLen = getFileLength(new File("d:/勇敢的心.rmvb"));
System.out.println("文件的大小" + fileLen);
//以輸出文件名創建第一個RandomAccessFile輸出流
outArr[0] = new RandomAccessFile(OUT_FILE_NAME, "rw");
//創建一個與文件相同大小的空文件
for (int i = 0; i < fileLen; i++) {
outArr[0].write(0);
}
//每線程應該讀取的位元組數
long numPerThred = fileLen / DOWN_THREAD_NUM;
//整個文件整除後剩下的余數
long left = fileLen % DOWN_THREAD_NUM;
for (int i = 0; i < DOWN_THREAD_NUM; i++) {
//為每個線程打開一個輸入流、一個RandomAccessFile對象，
//讓每個線程分別負責讀取文件的不同部分。
if (i != 0) {
isArr[i] = new FileInputStream("d:/勇敢的心.rmvb");
//以指定輸出文件創建多個RandomAccessFile對象
outArr[i] = new RandomAccessFile(OUT_FILE_NAME, "rw");
}
if (i == DOWN_THREAD_NUM - 1) {
//最後一個線程讀取指定numPerThred+left個位元組
new DownThread(i * numPerThred, (i + 1) * numPerThred
+ left, isArr[i], outArr[i]).start();
} else {
//每個線程負責讀取一定的numPerThred個位元組
new DownThread(i * numPerThred, (i + 1) * numPerThred,
isArr[i], outArr[i]).start();
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static long getFileLength(File file) {
long length = 0;
//獲取文件的長度
long size = file.length();
length = size;
return length;
}
}
G. java 如何獲取一個線程中的變數
你把他設置為私有的，當然獲取不了了，可以修改為public或者為該對象增加get，set方法
H. 怎樣獲取java線程中信息
？ 在進行多線程編程中，比較重要也是比較困難的一個操作就是如何獲取線程中的信息。大多數人會採取比較常見的一種方法就是將線程中要返回的結果存儲在一個欄位中，然後再提供一個獲取方法將這個欄位的內容返回給該方法的調用者。如以下的ReturnThreadInfo類：package threadtest1;/**** @author shi mingxiang*/public class ReturnThreadInfo extends Thread { private String str; public ReturnThreadInfo() { this.str = "Hello";}public void run(){ this.str = "Hello World!";}public String getThreadInfo(){ return this.str;}} 大家可以看到該類是一個線程類並含有一個初始值為"Hello"的欄位str以及一個可以返回str值的方法：getThreadInfo()，而且當這個線程啟動後str會被賦於新值:"Hello World!"。現在我想在另外一個類中啟動ReturnThreadInfo線程，並通過getThreadInfo()方法獲取值為"Hello World!"的變數並列印輸出到控制台中。以下給出一個實現該功能的Main類：package threadtest1;/**** @author shi mingxiang*/public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start(); //創建並啟動ReturnThreadInfo線程 System.out.println(returnThreadInfo.getThreadInfo()); //獲取並輸出returnThreadInfo對象的str的值}} 以上是一個多數熟悉單線程編程的人在第一反應下給出的實現方法。但是該類在運行的時候輸出的結果卻不是期望的"Hello World!"而是"Hello"，這是由於線程的競爭條件導致的（由於ReturnThreadInfo線程和Main線程的優先順序都為5，所以在很大幾率上ReturnThreadInfo線程的run()方法還沒有運行，Main類就已經運行System.out.println(returnThreadInfo.getThreadInfo())；將"Hello"輸出了。具體的原理可以參見另一篇文章："java多線程的幾點誤區"）。有的人可能會立即想到把ReturnThreadInfo線程的優先順序設高些（比如最大的10）就可以returnThreadInfo線程的run()方法先運行完，然後Main類的System.out.println(returnThreadInfo.getThreadInfo())再運行，這樣輸出的結就一定是期望的"Hello World!"了。這種通過調整線程優先順序的方法固然可以在某種程度上解決該問題，但是線程爭用CPU運行時間的原理卻決不僅僅只是優先順序高低的原因（優先順序高的線程並不意味著一定比優先順序低的線程先運行，只是幾率要更大一些）。你並不希望ReturnThreadInfo線程9999次都比Main先運行，卻在最關鍵的一次在Main之後再運行。因此下面給出兩種比較常見的獲取線程信息的方法： 一、輪詢 比較常見的一種解決方案是，讓線程類獲取方法在結果欄位設置之前返回一個標志值。然後主線程定時詢問獲取方法，看是否返回了標志之外的值。以下給出了具體的實現方法，該方法不斷測試str的值是否為"Hello"，如果不為"Hello"才列印輸出它。例如：package threadtest1;/**** @author shi mingxiang*/public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start(); //創建並啟動ReturnThreadInfo線程 while(true){ String str = returnThreadInfo.getThreadInfo(); if(!str.equals("Hello")){ System.out.println(returnThreadInfo.getThreadInfo());break;}}}} 二、回調 輪詢方法最大的特點是主類Main不斷詢問線程類是否結束，這實際上大量浪費了運行時間，特別是當線程特別多的時候。因此如果反過來在線程結束時，由線程自己告訴主類Main線程已經結束，然後Main再獲取並輸出str的值，這樣就避免了輪詢方法所帶來的不必要的系統開銷問題。 在具體的實現過程中，線程可以在結束時通過調用主類中的一個方法來實現告知功能，這種方法叫做回調。這樣主類Main就可以在等待線程結束時休息，也就不會佔用運行線程的時間。下面是修改後的Main類：public class Main{ public Main() {}/*** @param args the command line arguments*/public static void main(String[] args) { // TODO code application logic here ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo(); returnThreadInfo.start();}public static void receiveStr(String str){ System.out.println(str);}} 相比於前面，我們在Main類中添加了一個靜態方法receiveStr(String str)，該方法是供線程結束之前調用，通過參數str將要返回的線程信息返回給Main類並輸出顯示出來。下面是修改後的ReturnThreadInfo類，該類在線程結束前回調了Main.receiveStr方法，通知線程已結束。package threadtest1;/**** @author shi mingxiang*/public class ReturnThreadInfo extends Thread { private String str; public ReturnThreadInfo() { this.str = "Hello";}public void run(){ Main.receiveStr(str); //回調receiveStr方法}} 如果有很多個對象關心線程的返回的信息,線程可以保存一個回調對象列表。某個對象可以通過已經定義的一個對象將自己添加到列表中，表示自己對這些信息的關注。如果有多個類的實例關心這些信息，也可以定義一個interface，在interface中聲名回調方法，然後這些類都實現這個介面。其實這是典型的java處理事件的方法，這么做可以使得回調更靈活，可以處理涉及更多線程、對象和類的情況。稍後會給出這種模仿事件處理模型的回調的實現方法。 這種方案雖然能起到作用，但是它做了大量不需要做的工作。
I. java 線程中的run（）方法無返回值並且不停止，如何得到線程數據
可以讓線程實現Callable介面，實現call方法，可以把你需要的東西return回去，然後如果是線程池的話可以用Future對象的get（）方法來接收這個返回值。但是這樣做線程池也只會同步執行一個線程。
J. java 獲取線程實例
主線程直接或間接引用要銷毀線程的實例，後然調用要銷毀線程interrupt()方法中斷線程執行。
你的說意思我知道，但是讓別人去管理還不如讓自己管理線程銷毀，然後提供一個外部介面，讓別一條消息就可以中斷線程呢？Sun jdk documentation就是這樣建議的。具體你可以查看以下文章：
http://..com/question/149156342.html