線程面試編程題

Ⅰ python面試題，線程與進程的區別，Python中如何創建多線程

進程和線程

這兩個概念屬於操作系統，我們經常聽說，但是可能很少有人會細究它們的含義。對於工程師而言，兩者的定義和區別還是很有必要了解清楚的。

首先說進程，進程可以看成是 CPU執行的具體的任務 。在操作系統當中，由於CPU的運行速度非常快，要比計算機當中的其他設備要快得多。比如內存、磁碟等等，所以如果CPU一次只執行一個任務，那麼會導致CPU大量時間在等待這些設備，這樣操作效率很低。為了提升計算機的運行效率，把機器的技能盡可能壓榨出來，CPU是輪詢工作的。也就是說 它一次只執行一個任務，執行一小段碎片時間之後立即切換 ，去執行其他任務。

所以在早期的單核機器的時候，看起來電腦也是並發工作的。我們可以一邊聽歌一邊上網，也不會覺得卡頓。但實際上，這是CPU輪詢的結果。在這個例子當中，聽歌的軟體和上網的軟體對於CPU而言都是 獨立的進程 。我們可以把進程簡單地理解成運行的應用，比如在安卓手機裡面，一個app啟動的時候就會對應系統中的一個進程。當然這種說法不完全准確， 一個應用也是可以啟動多個進程的 。

進程是對應CPU而言的，線程則更多針對的是程序。即使是CPU在執行當前進程的時候，程序運行的任務其實也是有分工的。舉個例子，比如聽歌軟體當中，我們需要顯示歌詞的字幕，需要播放聲音，需要監聽用戶的行為，比如是否發生了切歌、調節音量等等。所以，我們需要 進一步拆分CPU的工作 ，讓它在執行當前進程的時候，繼續通過輪詢的方式來同時做多件事情。

進程中的任務就是線程，所以從這點上來說， 進程和線程是包含關系 。一個進程當中可以包含多個線程，對於CPU而言，不能直接執行線程，一個線程一定屬於一個進程。所以我們知道，CPU進程切換切換的是執行的應用程序或者是軟體，而進程內部的線程切換，切換的是軟體當中具體的執行任務。

關於進程和線程有一個經典的模型可以說明它們之間的關系，假設CPU是一家工廠，工廠當中有多個車間。不同的車間對應不同的生產任務，有的車間生產汽車輪胎，有的車間生產汽車骨架。但是工廠的電力是有限的，同時只能滿足一個廠房的使用。

為了讓大家的進度協調，所以工廠需要輪流提供各個車間的供電。 這里的車間對應的就是進程 。

一個車間雖然只生產一種產品，但是其中的工序卻不止一個。一個車間可能會有好幾條流水線，具體的生產任務其實是流水線完成的，每一條流水線對應一個具體執行的任務。但是同樣的， 車間同一時刻也只能執行一條流水線 ，所以我們需要車間在這些流水線之間切換供電，讓各個流水線生產進度統一。

這里車間里的 流水線自然對應的就是線程的概念 ，這個模型很好地詮釋了CPU、進程和線程之間的關系。實際的原理也的確如此，不過CPU中的情況要比現實中的車間復雜得多。因為對於進程和CPU來說，它們面臨的局面都是實時變化的。車間當中的流水線是x個，下一刻可能就成了y個。

了解完了線程和進程的概念之後，對於理解電腦的配置也有幫助。比如我們買電腦，經常會碰到一個術語，就是這個電腦的CPU是某某核某某線程的。比如我當年買的第一台筆記本是4核8線程的，這其實是在說這台電腦的CPU有 4個計算核心 ，但是使用了超線程技術，使得可以把一個物理核心模擬成兩個邏輯核心。相當於我們可以用4個核心同時執行8個線程，相當於8個核心同時執行，但其實有4個核心是模擬出來的虛擬核心。

有一個問題是 為什麼是4核8線程而不是4核8進程呢 ？因為CPU並不會直接執行進程，而是執行的是進程當中的某一個線程。就好像車間並不能直接生產零件，只有流水線才能生產零件。車間負責的更多是資源的調配，所以教科書里有一句非常經典的話來詮釋： 進程是資源分配的最小單元，線程是CPU調度的最小單元 。

啟動線程

Python當中為我們提供了完善的threading庫，通過它，我們可以非常方便地創建線程來執行多線程。

首先，我們引入threading中的Thread，這是一個線程的類，我們可以通過創建一個線程的實例來執行多線程。

from threading import Thread t = Thread(target=func, name='therad', args=(x, y)) t.start()

簡單解釋一下它的用法，我們傳入了三個參數，分別是 target，name和args ，從名字上我們就可以猜測出它們的含義。首先是target，它傳入的是一個方法，也就是我們希望多線程執行的方法。name是我們為這個新創建的線程起的名字，這個參數可以省略，如果省略的話，系統會為它起一個系統名。當我們執行Python的時候啟動的線程名叫MainThread，通過線程的名字我們可以做區分。args是會傳遞給target這個函數的參數。

我們來舉個經典的例子：

import time, threading # 新線程執行的代碼: def loop(n): print('thread %s is running...' % threading.current_thread().name) for i in range(n): print('thread %s >>> %s' % (threading.current_thread().name, i)) time.sleep(5) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread', args=(10, )) t.start() print('thread %s ended.' % threading.current_thread().name)

我們創建了一個非常簡單的loop函數，用來執行一個循環來列印數字，我們每次列印一個數字之後這個線程會睡眠5秒鍾，所以我們看到的結果應該是每過5秒鍾屏幕上多出一行數字。

我們在Jupyter里執行一下：

表面上看這個結果沒毛病，但是其實有一個問題，什麼問題呢？ 輸出的順序不太對 ，為什麼我們在列印了第一個數字0之後，主線程就結束了呢？另外一個問題是，既然主線程已經結束了， 為什麼Python進程沒有結束 ， 還在向外列印結果呢？

因為線程之間是獨立的，對於主線程而言，它在執行了t.start()之後，並 不會停留，而是會一直往下執行一直到結束 。如果我們不希望主線程在這個時候結束，而是阻塞等待子線程運行結束之後再繼續運行，我們可以在代碼當中加上t.join()這一行來實現這點。

t.start() t.join() print('thread %s ended.' % threading.current_thread().name)

join操作可以讓主線程在join處掛起等待，直到子線程執行結束之後，再繼續往下執行。我們加上了join之後的運行結果是這樣的：

這個就是我們預期的樣子了，等待子線程執行結束之後再繼續。

我們再來看第二個問題，為什麼主線程結束的時候，子線程還在繼續運行，Python進程沒有退出呢？這是因為默認情況下我們創建的都是用戶級線程，對於進程而言， 會等待所有用戶級線程執行結束之後才退出 。這里就有了一個問題，那假如我們創建了一個線程嘗試從一個介面當中獲取數據，由於介面一直沒有返回，當前進程豈不是會永遠等待下去？

這顯然是不合理的，所以為了解決這個問題，我們可以把創建出來的線程設置成 守護線程 。

守護線程

守護線程即daemon線程，它的英文直譯其實是後台駐留程序，所以我們也可以理解成 後台線程 ，這樣更方便理解。daemon線程和用戶線程級別不同，進程不會主動等待daemon線程的執行， 當所有用戶級線程執行結束之後即會退出。進程退出時會kill掉所有守護線程 。

我們傳入daemon=True參數來將創建出來的線程設置成後台線程：

t = threading.Thread(target=loop, name='LoopThread', args=(10, ), daemon=True)

這樣我們再執行看到的結果就是這樣了：

這里有一點需要注意，如果你 在jupyter當中運行是看不到這樣的結果的 。因為jupyter自身是一個進程，對於jupyter當中的cell而言，它一直是有用戶級線程存活的，所以進程不會退出。所以想要看到這樣的效果，只能通過命令行執行Python文件。

如果我們想要等待這個子線程結束，就必須通過join方法。另外，為了預防子線程鎖死一直無法退出的情況， 我們還可以 在joih當中設置timeout ，即最長等待時間，當等待時間到達之後，將不再等待。

比如我在join當中設置的timeout等於5時，屏幕上就只會輸出5個數字。

另外，如果沒有設置成後台線程的話，設置timeout雖然也有用，但是 進程仍然會等待所有子線程結束 。所以屏幕上的輸出結果會是這樣的：

雖然主線程繼續往下執行並且結束了，但是子線程仍然一直運行，直到子線程也運行結束。

關於join設置timeout這里有一個坑，如果我們只有一個線程要等待還好，如果有多個線程，我們用一個循環將它們設置等待的話。那麼 主線程一共會等待N * timeout的時間 ，這里的N是線程的數量。因為每個線程計算是否超時的開始時間是上一個線程超時結束的時間，它會等待所有線程都超時，才會一起終止它們。

比如我這樣創建3個線程：

ths = [] for i in range(3): t = threading.Thread(target=loop, name='LoopThread' + str(i), args=(10, ), daemon=True) ths.append(t) for t in ths: t.start() for t in ths: t.join(2)

最後屏幕上輸出的結果是這樣的：

所有線程都存活了6秒。

總結

在今天的文章當中，我們一起簡單了解了 操作系統當中線程和進程的概念 ，以及Python當中如何創建一個線程，以及關於創建線程之後的相關使用。

多線程在許多語言當中都是至關重要的，許多場景下必定會使用到多線程。比如 web後端，比如爬蟲，再比如游戲開發 以及其他所有需要涉及開發ui界面的領域。因為凡是涉及到ui，必然會需要一個線程單獨渲染頁面，另外的線程負責准備數據和執行邏輯。因此，多線程是專業程序員繞不開的一個話題，也是一定要掌握的內容之一。

Ⅱ java線程問題

不管你是新程序員還是老手，你一定在面試中遇到過有關線程的問題。Java語言一個重要的特點就是內置了對並發的支持，讓Java大受企業和程序員的歡迎。大多數待遇豐厚的Java開發職位都要求開發者精通多線程技術並且有豐富的Java程序開發、調試、優化經驗，所以線程相關的問題在面試中經常會被提到。
在典型的Java面試中， 面試官會從線程的基本概念問起, 如：為什麼你需要使用線程， 如何創建線程，用什麼方式創建線程比較好（比如：繼承thread類還是調用Runnable介面），然後逐漸問到並發問題像在Java並發編程的過程中遇到了什麼挑戰，Java內存模型，JDK1.5引入了哪些更高階的並發工具，並發編程常用的設計模式，經典多線程問題如生產者消費者，哲學家就餐，讀寫器或者簡單的有界緩沖區問題。僅僅知道線程的基本概念是遠遠不夠的， 你必須知道如何處理死鎖，競態條件，內存沖突和線程安全等並發問題。掌握了這些技巧，你就可以輕松應對多線程和並發面試了。
許多Java程序員在面試前才會去看面試題，這很正常。因為收集面試題和練習很花時間，所以我從許多面試者那裡收集了Java多線程和並發相關的50個熱門問題。我只收集了比較新的面試題且沒有提供全部答案。想必聰明的你對這些問題早就心中有數了， 如果遇到不懂的問題，你可以用Google找到答案。若你實在找不到答案，可以在文章的評論中向我求助。

Ⅲ Java面試題，線程的幾種狀態是什麼

線程在執行過程中，可以處於下面幾種狀態：

就緒(Runnable):線程准備運行，不一定立馬就能開始執行。
運行中(Running)：進程正在執行線程的代碼。
等待中(Waiting):線程處於阻塞的狀態，等待外部的處理結束。
睡眠中(Sleeping)：線程被強制睡眠。
I/O阻塞(Blocked on I/O)：等待I/O操作完成。
同步阻塞(Blocked on Synchronization)：等待獲取鎖。
死亡(Dead)：線程完成了執行。

Ⅳ Python編程面試常見問題有哪些

Python編程面試題目一：python下多線程的限制以及多進程中傳遞參數的方式，以及區別

(1)python下多線程的限制以及多進程中傳遞參數的方式

python多線程有個全局解釋器鎖(global interpreter lock)，這個鎖的意思是任一時間只能有一個線程使用解釋器，跟單cpu跑多個程序一個意思，大家都是輪著用的，這叫“並發”，不是“並行”。

多進程間共享數據，可以使用 multiprocessing.Value 和 multiprocessing.Array

(2)python多線程與多進程的區別

在UNIX平台上，當某個進程終結之後，該進程需要被其父進程調用wait，否則進程成為僵屍進程(Zombie)。所以，有必要對每個Process對象調用join()方法 (實際上等同於wait)。對於多線程來說，由於只有一個進程，所以不存在此必要性。

多進程應該避免共享資源。在多線程中，我們可以比較容易地共享資源，比如使用全局變數或者傳遞參數。在多進程情況下，由於每個進程有自己獨立的內存空間，以上方法並不合適。此時我們可以通過共享內存和Manager的方法來共享資源。但這樣做提高了程序的復雜度，並因為同步的需要而降低了程序的效率。

Python編程面試題目二：lambada函數

lambda 函數是一個可以接收任意多個參數(包括可選參數)並且返回單個表達式值的函數。 lambda 函數不能包含命令，它們所包含的表達式不能超過一個。不要試圖向lambda 函數中塞入太多的東西;如果你需要更復雜的東西，應該定義一個普通函數，然後想讓它多長就多長。

更多關於Python編程的技巧，干貨，資訊等內容，小編會持續更新。

Ⅳ 多線程面試題，沒有思路。還請達人指點。

這樣吧，我是根據前面同學的思路以生產者-消費者方式完成的一個java小demo。

第一個類：
共享值類。
public class ShareValue {
private int count;
public ShareValue(int count) {
this.count = count;
}
public synchronized void plus() throws InterruptedException {
if (count <= 100) {
++count;
System.out.println("Procer:" + count);
this.notifyAll();
} else {
System.out.println("值超過100，停止增加!");
this.wait();
}
}
public synchronized void minus() throws InterruptedException {
if (count > 0) {
--count;
System.err.println("Consumer:" + count);
this.notifyAll();
} else {
System.out.println("值小或等於0，停止減少!");
this.wait();
}
}
}

第二個類：
生產者類
public class Procer implements Runnable {
private ShareValue value;
public Procer(ShareValue value) {
this.value = value;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
try {
value.plus();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

第三個類：
消費者類
public class Consumer implements Runnable {
private ShareValue value;
public Consumer(ShareValue value) {
this.value = value;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
try {
value.minus();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

第四個：
測試類
public class TestPC {
public static void main(String[] args) {
ShareValue value = new ShareValue(0);
Runnable pr = new Procer(value);
Runnable cr = new Consumer(value);
new Thread(pr).start();
new Thread(cr).start();
}
}

希望對你有所幫助，這只是能初步跑起來，可以觀察運行，後面可以逐步調整。

Ⅵ 哪裡有關於多線程的 c#面試題

來表示
2.同步因子,在某段代碼上增加同步因子,那麼整個JVM內部只能最多有一個線程執行這段,其餘的線程按FIFO方式等待執行.

Ⅶ JAVA面試題 JAVA中創建線程有幾種不同的方式

第一種方式：使用Runnable介面創建線程
第二種方式：直接繼承Thread類創建對象
使用Runnable介面創建線程
1.可以將CPU，代碼和數據分開，形成清晰的模型
2.線程體run()方法所在的類可以從其它類中繼承一些有用的屬性和方法
3.有利於保持程序的設計風格一致
直接繼承Thread類創建對象
1.Thread子類無法再從其它類繼承（java語言單繼承）。
2.編寫簡單，run()方法的當前對象就是線程對象，可直接操作。
在實際應用中，幾乎都採取第一種方式

Ⅷ 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();
}
}

Ⅸ 某公司面試題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面試題

有三種方式可以用來創建線程：
繼承Thread類
實現Runnable介面
應用程序可以使用Executor框架來創建線程池

實現Runnable介面這種方式更受歡迎，因為這不需要繼承Thread類。在應用設計中已經繼承了別的對象的情況下，這需要多繼承（而Java不支持多繼承），只能實現介面。同時，線程池也是非常高效的，很容易實現和使用。