java多線程面試

① Java 面試 真是的項目中 多線程主要用在哪 謝謝

多線程主要用在網路開發上面,客戶端對伺服器的多種請求,多線程可以增加訪問速度

GUI的部分要用多線程

② java面試什麼是多線程

線程定義比較抽象，簡單的說就是一個代碼執行流。許多執行流可以專混合在一起由CPU調度。線程是允屬許各種任務交互執行的方式。

Java的線程在操作系統的實現模式依系統不同而不同，可能是系統級別的進程或線程，但對於程序員來說並沒有影響。

任務交互的一個好處是增加程序響應。如一個界面程序執行一段耗時的資料庫查詢，使用單獨的線程可以讓界面依然響應用戶的其他輸入，而單線程只能等待查詢結束再處理。

JVM以及操作系統會優先處理優先順序別高的線程，但不代表這些線程一定會先完成。設定優先順序只能建議系統更快的處理，而不能強制。

另外，在運行時，並沒有按照函數分界，而是按照機器碼/匯編碼分界。也就是說不保證任何一段代碼是被完整而不打斷的執行的（除非你已經使用同步手段）。正由於如此，各種線程同步的方法應運而生。

③ java多線程runnable和thread的區別 面試題

runnable和thread的區別（多線程必須用Runable）
Java中有兩種實現多線程的方式以及兩種方式之間的區別
看到一個面試題.問兩種實現多線程的方法.沒事去網上找了找答案.
網上流傳很廣的是一個網上售票系統講解.轉發過來.已經不知道原文到底是出自哪裡了.

Java中有兩種實現多線程的方式。一是直接繼承Thread類，二是實現Runnable介面。那麼這兩種實現多線程的方式在應用上有什麼區別呢？
為了回答這個問題，我們可以通過編寫一段代碼來進行分析。我們用代碼來模擬鐵路售票系統，實現通過四個售票點發售某日某次列車的100張車票，一個售票點用一個線程表示。
首先這樣編寫這個程序：

Java代碼
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源碼列印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}

main測試類:

Java代碼
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
源碼列印？
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}

上面的代碼中，我們用ThreadTest類模擬售票處的售票過程，run方法中的每一次循環都將總票數減1，模擬賣出一張車票，同時該車票號列印出來，直接剩餘的票數到零為止。在ThreadDemo1類的main方法中，我們創建了一個線程對象，並重復啟動四次，希望通過這種方式產生四個線程。從運行的結果來看我們發現其實只有一個線程在運行，這個結果 告訴我們：一個線程對象只能啟動一個線程，無論你調用多少遍start()方法，結果只有一個線程。

我們接著修改ThreadDemo1，在main方法中創建四個Thread對象：

Java代碼
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
源碼列印？
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}

Java代碼
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源碼列印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}

這下達到目的了嗎？

從結果上看每個票號都被列印了四次，即 四個線程各自賣各自的100張票，而不去賣共同的100張票。這種情況是怎麼造成的呢？我們需要的是，多個線程去處理同一個資源，一個資源只能對應一個對象，在上面的程序中，我們創建了四個ThreadTest對象，就等於創建了四個資源，每個資源都有100張票，每個線程都在獨自處理各自的資源。

經過這些實驗和分析，可以總結出，要實現這個鐵路售票程序，我們只能創建一個資源對象，但要創建多個線程去處理同一個資源對象，並且每個線程上所運行的是相同的程序代碼。在回顧一下使用介面編寫多線程的過程。

Java代碼
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
源碼列印？
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}

Java代碼
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}
源碼列印？
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}

上面的程序中，創建了四個線程， 每個線程調用的是同一個ThreadTest對象中的run()方法，訪問的是同一個對象中的變數（tickets）的實例，這個程序滿足了我們的需求。在Windows上可以啟動多個記事本程序一樣，也就是多個進程使用同一個記事本程序代碼。

可見， 實現Runnable介面相對於繼承Thread類來說，有如下顯著的好處：

(1)適合多個相同程序代碼的線程去處理同一資源的情況，把虛擬CPU（線程）同程序的代碼，數據有效的分離，較好地體現了面向對象的設計思想。

(2)可以避免由於Java的單繼承特性帶來的局限。我們經常碰到這樣一種情況，即當我們要將已經繼承了某一個類的子類放入多線程中，由於一個類不能同時有兩個父類，所以不能用繼承Thread類的方式，那麼，這個類就只能採用實現Runnable介面的方式了。

(3)有利於程序的健壯性，代碼能夠被多個線程共享，代碼與數據是獨立的。當多個線程的執行代碼來自同一個類的實例時，即稱它們共享相同的代碼。多個線程操作相同的數據，與它們的代碼無關。當共享訪問相同的對象是，即它們共享相同的數據。當線程被構造時，需要的代碼和數據通過一個對象作為構造函數實參傳遞進去，這個對象就是一個實現了Runnable介面的類的實例。

④ 某公司面試題java11使用並發多線程加速下載文件，如何寫

先建一個用於下載文件的多線程類，通常要指明下載文件的位置(URL)和文件名以及保存到本地的路徑
public class FileDownloader implements Runnable
{
private static File file;//要下載的文件
private static String url;//文件所在URL
private static File storagePath;//保存路徑
public static void initialize(File file, String url, File storagePath)//初始化靜態欄位，初始化的代碼不用我寫吧
}
然後，指明同步塊，目的是讓各個線程共享一個文件資源，那樣它們可以知道同一個文件的下載狀況(即獲取其他線程下載文件到哪個位置，以防重復下載)
public synchronized void fileDownload()//此方法用於下載文件，一般的Java程序員都會寫，實在不會我可以幫你補上
或者
public void fileDownload(){
synchronized(file){
synchronized(url){
synchronized(storagePath){
}}}}//給每個欄位加上同步塊
run()方法的實現就以自己的喜好去寫吧，只要裡面調用了fileDownload()方法就行。
public void run(){
…
fileDownload();//下載文件
…
}
然後，在主類的main方法中創建一個多線程數組:
Runnable[] fds=new FileDownloader[線程數量];//fds為file_downloaders縮寫
Thread[] threads=new Thread[線程數量];
最後使用循環把所有的線程逐一啟動。
for(int i=0;i<線程數量;i++){
threads[i]=new Thread(fds[i]);
threads[i].start();
}

⑤ java面試 談談多線程 ,怎麼回答

就談談你理解的多線程是什麼樣子的，說說多線程的一般使用情況、適用情況和基本的一些函數，怎麼實現多線程，多線程和單線程的區別，就OK了，他要再深問再深入說咯。。。。

⑥ 面試的時候都會問到多線程的問題，但實際很多項目並不會涉及到，那麼java中什麼類型的數據需要多線程處理

多個線程都會操作的數據，也叫臨界區數據。

就像幾個廚子共用一把刀和菜板，為避版免一權人拿刀，一人拿菜板，分配一定要同時分配給一個人。

其實就是這個意思，多線程編程需要處理的就是這樣，多個數據有邏輯完整性的情況。需要鎖定資源，進行多線程互斥操作。說起來很玄妙，其實就是和分刀和菜板一個道理。

⑦ java有關線程的面試題

http://..com/question/346850241.html

⑧ java 面試 什麼是多線程

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

補充內容

線程與進程的區別：

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

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

舉例說明：

publicclassThreadTest{

	publicstaticvoidm1(){

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

	publicstaticvoidm2(){

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

	publicstaticvoidm3(){

		m1();
		m2();
	}

	publicstaticvoidmain(String[]args){

		m3();
	}}

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

⑨ java 線程面試題

我不知道你是不是這個意思，thread1，thread2兩個線程每次讓j增加1，thread3，thread4兩個線程每次讓j減少1，四個線程每個都調用250次相關加減一操作。最終j的結果都是100.
下面程序，總計會列印出1000個數，不管怎麼樣最後一個數永遠是100，即j的終值永遠是100，為了看中間結果運行過程我加了sleep，但無關緊要。你看看符合你要求不？
就像樓上說的，啟動1000條線程不是很明白，不一致的繼續討論
package com.kalort;

public class ThreadTest
{
public static void main(String[] args)
{
Operator operator = new Operator();
Thread thread1 = new IncreaseThread(operator);
Thread thread2 = new IncreaseThread(operator);
Thread thread3 = new DecreaseThread(operator);
Thread thread4 = new DecreaseThread(operator);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}

class IncreaseThread extends Thread
{
private Operator operator;

public IncreaseThread(Operator operator)
{
this.operator = operator;
}

public void run()
{
for (int i = 0; i < 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.increase();
}
}
}

class DecreaseThread extends Thread
{
private Operator operator;

public DecreaseThread(Operator operator)
{
this.operator = operator;
}

public void run()
{
for (int i = 0; i < 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.decrease();
}
}
}

class Operator
{
private int j = 100;

public synchronized void increase()
{
while (100 != j)
{
try
{
wait(); // 如果另外線程還沒減一就等待
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
j++;
System.out.println(j);
notify(); // 通知另外線程已經加一了。
}

public synchronized void decrease()
{
while (100 == j)
{
try
{
wait();
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
j--;
System.out.println(j);
notify();
}
}

⑩ 面試問 關於JAVA多線程,從哪些方面回答呢

1. 應用場景

   即作用是什麼，哪些場景下需要，能解決哪類問題，通常情況下面試版官更關心這權個。

   
   

2. 實現方式

   除了什麼時候用，你還得告訴他怎麼用。什麼Thread、Runnable、線程池之類的丟上去，這些比較基礎。

   
   

3. 線程同步

   這個問題其實比較復雜。線程同步的概念最易於理解的案例就是在生產者消費者模式中的應用，你可以跟他講講這個。當然，這個涉及到對象鎖基本就夠了。

   然後你再說說線程同步的幾個方式，synchronized（對象、方法）、Lock、wait/notify之類的，說說它們的區別和應用場景。

   最後提一提JDK中那些容器的線程同步問題，這樣基本的使用算是不會有大問題了。

上面的東西你都能講清楚，你多線程上的內容也就回個7788了，這塊兒的面試基本沒問題了