❶ 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、兩個線程，一個線程執行開門操作，一個線程執行關門操作，並都進行同步處理（synchronized)
2、假如在開門期間，按下按鈕，剛開門線程wait， 並notify關門線程開始run, 同理在關門期間，如果
按下按鈕，則關門線程wait, 並notify開門線程執行
3、有一個注意的地方，每當在開門或關門期間按下按鈕的時候，都要記錄開門或關門最後一刻的狀態值，以便在下次執行時，開門的從上一次關門最後一刻的狀態開始執行，而關門的則上一個開門的最後一刻狀態開始執行。個人見解。。。

❸ java有關線程的面試題

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

❹ 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中啟動線程3種方法不是只有star（）嗎

實現Runnable介面：
1）適合多個相同的程序代碼的線程去處理同一個資源
2）可以避免java中的單繼承的限制
3）增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立。
繼承Thread類：
1）可以將線程類抽象出來，當需要使用抽象工廠模式設計時。
2）多線程同步
在函數體使用（也就是star）
1）無需繼承thread或者實現Runnable，縮小作用域。

❼ java筆試題：從線程和安全說一下sleep()和wait（）的區別

這兩者的施加者是有本質區別的.
sleep()是讓某個線程暫停運行一段時間,其控制范圍是專由當前線程決屬定,也就是說,在線程裡面決定.好比如說,我要做的事情是 "點火->燒水->煮麵",而當我點完火之後我不立即燒水,我要休息一段時間再燒.對於運行的主動權是由我的流程來控制.

而wait(),首先,這是由某個確定的對象來調用的,將這個對象理解成一個傳話的人,當這個人在某個線程裡面說"暫停!",也是thisOBJ.wait(),這里的暫停是阻塞,還是"點火->燒水->煮飯",thisOBJ就好比一個監督我的人站在我旁邊,本來該線程應該執行1後執行2,再執行3,而在2處被那個對象喊暫停,那麼我就會一直等在這里而不執行3,但正個流程並沒有結束,我一直想去煮飯,但還沒被允許,直到那個對象在某個地方說"通知暫停的線程啟動!",也就是thisOBJ.notify()的時候,那麼我就可以煮飯了,這個被暫停的線程就會從暫停處繼續執行.

其實兩者都可以讓線程暫停一段時間,但是本質的區別是一個線程的運行狀態控制,一個是線程之間的通訊的問題

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

  1. 應用場景

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


  2. 實現方式

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


  3. 線程同步

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

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

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


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

❾ java面試題 java多線程中有哪些鎖

jvm自帶一個鎖機制，著一般需要知道，
synchronized鎖，掃描全部線程，耗費內存較多，
lock鎖

❿ 朋友們，今天去面試一家游戲公司的Java開發，有兩道題：一道是多線程的實際應用中的題目，一道是SQL的

去了幾天就被淘汰下來，你覺得值嗎？直接問答案，還不如自己在網上搜索。