java多線

① java 面試 什麼是多線程

多線程是指一個應用程序同時執行多個任務，一般來說一個任務就是一個線程 ，而一個應用程序有一個以上的線程我們稱之為多線程。

補充內容

線程與進程的區別：

• 進程(程序)：是靜態概念，一個class文件、一個exe文件

• 線程：是一個程序裡面不同的執行路徑

舉例說明：

publicclassThreadTest{

	publicstaticvoidm1(){

		System.out.println("m1");
	}

	publicstaticvoidm2(){

		System.out.println("m2");
	}

	publicstaticvoidm3(){

		m1();
		m2();
	}

	publicstaticvoidmain(String[]args){

		m3();
	}}

程序中的路徑或者線程也就是main方法(共一條)：

② java實現多線程的兩種方法

Thread t1=new Thread(){
public void run(){
System.out.println("第一種方法");
}
};
t1.start();
Thread t2=new Thread(new Runnable() {
public void run() {
System.out.println("第二種方法，可實現同類下各線程數據共享");
}
});
t2.start();

③ Java的多線程有什麼用處

java的多線程一般用於網路層
簡單的理解，你訪問網站的時候肯定有過一次開很多個網頁，然後再去一個個看，這個就是多線程的類似原理。
單線程可以理解為你每次只開一個網頁，要看其他網頁的時候先關了原來的網頁後才去訪問一個新網頁。
單線程的缺點是順序執行，只有一個結束了，下一個才會執行，如果網路阻塞等原因，程序會一直等待返回信息而什麼都不去做了，這樣就造成了效率的降低。
多線程會分段分步執行，如果一個線程卡死在網路上面（也就是打不開網頁的情況），他不會一直等待，會先執行其他的訪問，然後再回來看一下卡死的線程是否能繼續，如果設置了超時會報錯然後釋放那個線程。

④ 用Java實現多線程有哪些途徑

1，創建Thread類的子類
在這個途徑中，用戶程序需要創建自己的Thread類的子類，並在子類中重新定義自己的run()方法，這個run()方法中包含了用戶線程的操作。這樣在用戶程序需要建立自己的線程時，它只需要創建一個已定義好的Thread子類的實例就可以了。
例：
public class TestThread{
...(中間的就不寫了)
}
class Test1 extends Thread{
public void run(){
...............
}
}
2.實現Runnable介面
在這個途徑中，已經有了一個父類的用戶類可以通過實現Runnable介面的方法來定義用戶線程的操作。Runnable介面只有一個方法run()，實現這個借口，就必須要定義run()方法的具體內容，用戶新建線程的操作也就由這個方法來決定。定義好run()方法之後，當用戶程序需要建立新線程時，只要以這個實現了run()方法的類對象為參數創建系統類Thread的對象，就可以把用戶實現的run()方法借用過來。
public class TestRunnable implements Runnable{
Lable prompt1 = new Label("1");
Lable prompt2 = new Label("2");
.......
Thread thread1,thread2;
.......
}
public void init(){
add(.....);
.......
.......
}
public void start(){
thread1 = new Thread(........);//（我就寫一個。）創建1,2個線程對象，其他的不寫了
thread1.start();
}
public void run(){........}
}

⑤ 多線程有哪些實現方式

java多線程的幾種實現方式：
1.繼承Thread類，重寫run方法
2.實現Runnable介面，重寫run方法，實現Runnable介面的實現類的實例對象作為Thread構造函數的target
3.通過Callable和FutureTask創建線程
4.通過線程池創建線程 （上一篇已經講過了）
前面兩種可以歸結為一類：無返回值，原因很簡單，通過重寫run方法，run方式的返回值是void，所以沒有辦法返回結果
後面兩種可以歸結成一類：有返回值，通過Callable介面，就要實現call方法，這個方法的返回值是Object，所以返回的結果可以放在Object對象中

⑥ java 多線程是什麼一個處理器怎麼同時處理多個程序

進程是程序在處理機中的一次運行。一個進程既包括其所要執行的指令，也包括了執行指令所需的系統資源，不同進程所佔用的系統資源相對獨立。所以進程是重量級的任務，它們之間的通信和轉換都需要操作系統付出較大的開銷。
線程是進程中的一個實體，是被系統獨立調度和分派的基本單位。線程自己基本上不擁有系統資源，但它可以與同屬一個進程的其他線程共享進程所擁有的全部資源。所以線程是輕量級的任務，它們之間的通信和轉換只需要較小的系統開銷。
Java支持多線程編程，因此用Java編寫的應用程序可以同時執行多個任務。Java的多線程機制使用起來非常方便，用戶只需關注程序細節的實現，而不用擔心後台的多任務系統。
Java語言里，線程表現為線程類。Thread線程類封裝了所有需要的線程操作控制。在設計程序時，必須很清晰地區分開線程對象和運行線程，可以將線程對象看作是運行線程的控制面板。在線程對象里有很多方法來控制一個線程是否運行，睡眠，掛起或停止。線程類是控制線程行為的唯一的手段。一旦一個Java程序啟動後，就已經有一個線程在運行。可通過調用Thread.currentThread方法來查看當前運行的是哪一個線程。

class ThreadTest{
public static void main(String args[]){
Thread t = Thread.currentThread();
t.setName("單線程"); //對線程取名為"單線程"
t.setPriority(8);
//設置線程優先順序為8，最高為10，最低為1，默認為5
System.out.println("The running thread: " + t);
// 顯示線程信息
try{
for(int i=0;i<3;i++){
System.out.println("Sleep time " + i);
Thread.sleep(100); // 睡眠100毫秒
}
}catch(InterruptedException e){// 捕獲異常
System.out.println("thread has wrong");
}
}
}

多線程的實現方法
繼承Thread類
可通過繼承Thread類並重寫其中的run()方法來定義線程體以實現線程的具體行為，然後創建該子類的對象以創建線程。
在繼承Thread類的子類ThreadSubclassName中重寫run()方法來定義線程體的一般格式為:
public class ThreadSubclassName extends Thread{
public ThreadSubclassName(){
..... // 編寫子類的構造方法，可預設
}
public void run(){
..... // 編寫自己的線程代碼
}
}
用定義的線程子類ThreadSubclassName創建線程對象的一般格式為:
ThreadSubclassName ThreadObject =
new ThreadSubclassName();
然後，就可啟動該線程對象表示的線程：
ThreadObject.start(); //啟動線程

應用繼承類Thread的方法實現多線程的程序。本程序創建了三個單獨的線程，它們分別列印自己的「Hello World!」。
class ThreadDemo extends Thread{
private String whoami;
private int delay;
public ThreadDemo(String s,int d){
whoami=s;
delay=d;
}
public void run(){
try{
sleep(delay);
}catch(InterruptedException e){ }
System.out.println("Hello World!" + whoami
+ " " + delay);
}
}
public class MultiThread{
public static void main(String args[]){
ThreadDemo t1,t2,t3;
t1 = new ThreadDemo("Thread1",
(int)(Math.random()*2000));
t2 = new ThreadDemo("Thread2",
(int)(Math.random()*2000));
t3 = new ThreadDemo("Thread3",
(int)(Math.random()*2000));
t1.start();
t2.start();
t3.start();
}
}

實現Runnable介面
編寫多線程程序的另一種的方法是實現Runnable介面。在一個類中實現Runnable介面(以後稱實現Runnable介面的類為Runnable類),並在該類中定義run()方法，然後用帶有Runnable參數的Thread類構造方法創建線程。
創建線程對象可用下面的兩個步驟來完成:
(1)生成Runnable類ClassName的對象
ClassName RunnableObject = new ClassName();
(2)用帶有Runnable參數的Thread類構造方法創建線程對象。新創建的線程的指針將指向Runnable類的實例。用該Runnable類的實例為線程提供 run()方法---線程體。
Thread ThreadObject = new Thread(RunnableObject);
然後，就可啟動線程對象ThreadObject表示的線程：
ThreadObject.start();
在Thread類中帶有Runnable介面的構造方法有:
public Thread(Runnable target);
public Thread(Runnable target, String name);
public Thread(String name);
public Thread(ThreadGroup group，Runnable target);
public Thread(ThreadGroup group，Runnable target，
String name);
其中，參數Runnable target表示該線程執行時運行target的run()方法，String name以指定名字構造線程，ThreadGroup group表示創建線程組。
用Runnable介面實現的多線程。
class TwoThread implements Runnable{
TwoThread(){
Thread t1 = Thread.currentThread();
t1.setName("第一主線程");
System.out.println("正在運行的線程: " + t1);
Thread t2 = new Thread(this,"第二線程");
System.out.println("創建第二線程");
t2.start();
try{
System.out.println("第一線程休眠");
Thread.sleep(3000);
}catch(InterruptedException e){
System.out.println("第一線程有錯");
}
System.out.println("第一線程退出");
}
public void run(){
try{
for(int i = 0;i < 5;i++){
System.out.println(「第二線程的休眠時間：」
+ i);
Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println("線程有錯");
}
System.out.println("第二線程退出");
}
public static void main(String args[]){
new TwoThread();
}
}
程序運行結果如下：
正在運行的線程: Thread[第一主線程,5,main
創建第二線程
第一線程休眠
第二線程的休眠時間：0
第二線程的休眠時間：1
第二線程的休眠時間：2
第一線程退出
第二線程的休眠時間：3
第二線程的休眠時間：4
第二線程退出

至於一個處理器同時處理多個程序，其實不是同時運行多個程序的，簡單的說，如果是單核的CPU，在運行多個程序的時候其實是每個程序輪流佔用CPU的，只是每個程序佔用的時間很短，所以我們人為的感覺是「同時」運行多個程序。