欲觀原文，請君移步

OSD簡介

OSD，on-screen display的簡稱，即屏幕菜單式調節方式。一般我們按一下Menu鍵后屏幕彈出的显示器各項調節項目信息的矩形菜單，比如調亮度，色調，飽和度等信息，這個显示這個菜單的功能就是視頻行業的OSD。

基於FPGA的OSD設計與實現

1 Xilinx OSD IP功能

• 支持最多8個layer
• 背景顏色可編程
• 位置，大小，顏色，透明度（alpha）可編程
• 支持RGB和YUV視頻流

2 硬件結構框圖

硬件平台是基於xilinx xc7z035芯片開發的，關鍵模塊框圖如下圖1所示。

• 一個時序產生模塊Video Timing Controller(在本次實驗中採用1080P標準時序)

• 首先PL端將視頻流通過VDMA讀出，輸出接口為AXI4-Stream的數據流

• 然後視頻流進入OSD IP(OSD輸入輸出也是AXI4-Stream接口)

• 最後OSD輸出數據流與1080P時序同時送入到AXI4-Stream to Video Out模塊，輸出為HDMI接口

下面小編會詳細介紹OSD IP的例化與使用

3 OSD PL端

如果在使用OSD IP過程中出現如下錯誤，請在xilinx官網上申請OSD的License，這裏不再詳述如何申請License。

首先在Block Design中加入Video On Screen Display，打開後會看到如下圖2。

(1) 勾選AXI-Lite Interface：PS端通過AXI-Lite進行配置該IP

(2) Video Format選擇RGB

(3) Layers選擇2

(4) Layer Configuration：LAYER0選擇外部視頻流，也就是實時視頻，LAYER1選擇Internal，PS端可以控制進行圖文疊加

點擊Screen Layout Options，如圖3所示

(1) Background size（選擇背景大小）里寬度輸入1920，高度輸入1080

(2) Background color輸入背景顏色，這裏選擇黑色，可以通過axi-lite來控制

(3) layer0因為選擇的是外部視頻流，所以比如設置為外部視頻流分辨率，輸錯了，可能無法正常使用，小編已經遇到過了，本文使用1920×1080外部視頻流

(4) layer1因為選擇的是內部圖像控制器，所以無所謂設置什麼，可以通過axi-lite控制，所以選擇默認即可

點擊LAYER 1 Options出現圖4界面：因為是內部圖像控制器，所以可以進行一些配置，比如顏色多少，字符數目，比特像素等等，這裏小編選擇的是默認。

配置完OSD IP后，將其AXI-lite掛在總線上即可，然後保存Block Design即可。

注：點開Address Editor，一定要確定該IP被分配地址空間，如果沒有，點擊一下自動分配（小編遇到的問題就是這個ip地址空間在unmap里，導致後續PS端OSD IP無法初始化）。

4 OSD PS端

下面就是常規操作include bitstream導出SDK，其實就是生成hdf文件，硬件信息。然後就launch SDk。如圖4所示，可以看到hdf文件里都有什麼。

新建一個design_top的空工程，如圖5所示，在design_top_bsp下面可以看到system.mss文件，在紅框中找到OSD IP。

點擊import examples，出現如圖6所示，勾選對話框后選擇OK（不會玩IP先整個example）。

打開XosdSelfTestExample.c即可看到該例子程序是怎麼個處理流程（圖7為main函數，圖8為使用流程）小編稱之為PS端IP使用三步法

• 第一步先進行lookup該IP

• 第二步就是初始化該IP

• 第三步就是使用IP

運行一下，結果如圖9所示，可以看到UART會打印OSD成功信息。

OSD 實例

閑話不說，上面經過了OSD example，小編也作為一個PS端初學者來玩一玩。

尷尬的是經常在寫c代碼的時候想着寫begin…end，真是verilog寫習慣了，思想難以改變，原來是花括弧啊{}

初始化模塊如下

在初始化后必須將該模塊進行複位，然後，否則該IP啟動不了。

int OsdInit(int DeviceID)
{
	int Status;
	/* Initialize the OSD instance */
	OsdCfgPtr = XOSD_LookupConfig(DeviceID);
	Status = XOSD_CfgInitialize(&Osd, OsdCfgPtr,OsdCfgPtr->BaseAddress);
	if (Status != XST_SUCCESS)		return 1;
	/* Reset the devices */
	XOSD_Reset(&Osd);
	/* Enable the OSD device and tell it to pick up the register changes	*/
	XOSD_Enable(&Osd);
	XOSD_RegUpdateEnable(&Osd);
	return 0;
}

配置模塊

這裏需要注意的是把BANKIndex輸入為1，否則會進行字符填寫方式就需要改變，不符合操作習慣XOSD_LoadCharacterSetBank(&Osd, Gcindex, 1, (u32 *)Font);

void Graphics_setting(u8 Gcindex,u8 LayerPriority,u32 ColorData[],u32 *TextData)
{
	int width = 1920;
	int height = 1080;
	int LayerAlphaValue = 0xFF;
	int LayerGlobalAlphaEnable = 0;
	XOSD_SetLayerAlpha(&Osd, Gcindex, LayerGlobalAlphaEnable,LayerAlphaValue);
	XOSD_SetLayerPriority(&Osd, Gcindex, LayerPriority);
	XOSD_SetLayerDimension(&Osd, Gcindex, 0, 0, width, height);
	XOSD_EnableLayer(&Osd, Gcindex);
	/* Load color, font and text and set the active banks */
	XOSD_LoadColorLUTBank(&Osd, Gcindex, 0, ColorData);
	//set BankIndex is 1(fit our keyboard)
	XOSD_LoadCharacterSetBank(&Osd, Gcindex, 1, (u32 *)Font);
	XOSD_LoadTextBank(&Osd, Gcindex, 0, (u32 *)TextData);
	XOSD_SetActiveBank(&Osd, Gcindex, 0, 0, 0, 0);
}

圖文疊加模塊

void OsdDrawText(int Gcindex,int x_pos, int y_pos, int color, int string_index, int text_size)
{
	u32 Instruction[XOSD_INS_SIZE];
	u16 ObjType = XOSD_INS_OPCODE_BOXTXT; /* A text string 	XOSD_INS_OPCODE_TXT*/
	u8 ObjSize = (text_size<<4); /* Text Scale factor (1x, 2x, 4x, 8x)	*/
	u16 XStart = x_pos; /* Horizontal start pixel of the text	*/
	u16 YStart = y_pos; /* Vertical start line of the text */
	u16 XEnd = x_pos; /* Horizontal end pixel of the text (not	used) */
	u16 YEnd = y_pos; /* Vertical end line of the text (must be same as YStart) */
	u8 TextIndex = string_index; /* Index of Text String */
	u8 ColorIndex = color; /* Color used to draw text */


	XOSD_CreateInstruction(&Osd, Instruction, Gcindex,ObjType, ObjSize,	XStart, YStart, XEnd, YEnd,TextIndex, ColorIndex);
	XOSD_LoadInstructionList(&Osd, Gcindex, 0, Instruction, 1);
	return;
}

實現結果

前面只給出了兩個圖層，工程退不回去了，目前工程實現的是疊加8個圖層（1個視頻，7個內部圖像控制器）。

參考鏈接

百度網盤源碼以及參考文檔鏈接如下

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準

前文傳送門：

「Python 圖像處理 OpenCV （1）：入門」

「Python 圖像處理 OpenCV （2）：像素處理與 Numpy 操作以及 Matplotlib 显示圖像」

「Python 圖像處理 OpenCV （3）：圖像屬性、圖像感興趣 ROI 區域及通道處理」

「Python 圖像處理 OpenCV （4）：圖像算數運算以及修改顏色空間」

「Python 圖像處理 OpenCV （5）：圖像的幾何變換」

圖像的閾值

看到這個詞可能大家都很懵，為啥在圖像處理裏面還會有閾值。

圖像的閾值處理用大白話講就是將圖像轉化為二值圖像（黑白圖），目的是用來提取圖像中的目標物體，將背景和噪聲區分開（可以近似的認為除了目標全是噪聲）。

通常會設定一個閾值 T ，通過 T 將圖像的像素劃分為兩類：大於 T 的像素群和小於 T 的像素群。

首先可以先將圖像轉化為灰度圖像，因為在灰度圖像中，每個像素都只有一個灰度值用來表示當前像素的亮度。

接下來二值化處理可以將圖像中的像素劃分為兩類顏色，一種是大於閾值 T 的，另一種是小於閾值 T 的。

比如最常見的二值圖像：

當灰度值小於閾值 T 的時候，可以將其像素設置為 0 ，表示為黑色。

當灰度值大於閾值 T 的時候，可以將其像素設置為 255 ，表示為白色。

在 OpenCV 中，為我們提供了閾值函數 threshold() 來幫助我們實現二值圖像的處理。

函數如下：

retval, dst = threshold(src, thresh, maxval, type, dst=None)

• retval: 閾值
• dst: 處理后的圖像
• src: 原圖像
• thresh: 閾值
• maxval: 最大值
• type: 處理類型

常用的 5 中處理類型如下：

• cv.THRESH_BINARY: 二值處理
• cv.THRESH_BINARY_INV: 反二值處理
• cv.THRESH_TRUNC: 截斷閾值化
• cv.THRESH_TOZERO: 閾值化為 0
• cv.THRESH_TOZERO_INV: 反閾值化為 0

接下來這幾種處理類型有啥不同，我們一個一個來看。

二值處理

這種二值處理方式最開始需要選定一個閾值 T ，從 0 ~ 255 之間，我這裏選擇出於中間的那個數 127 。

接下來的處理規則就是這樣的：

• 大於等於 127 的像素點的灰度值設定為最大值，也就是 255 白色
• 小於 127 的像素點的灰度值設定為 0 ，也就是黑色

接下來開始寫代碼，看我們的馬里奧同學（不知道你們還記不記得我們的馬里奧同學）：

import cv2 as cv

src = cv.imread("maliao.jpg")

# BGR 圖像轉灰度
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 二值圖像處理
r, b = cv.threshold(gray_img, 127, 255, cv.THRESH_BINARY)

# 显示圖像
cv.imshow("src", src)
cv.imshow("result", b)

# 等待显示
cv.waitKey(0)
cv.destroyAllWindows()

反二值處理

這種方式和上面的二值處理非常相似，只是把處理規則給反了一下：

• 大於等於 127 的像素點的灰度值設定為 0 ，也就是白色
• 小於 127 的像素點的灰度值設定為最大值，也就是 255 白色

完整代碼如下：

import cv2 as cv

src = cv.imread("maliao.jpg")

# BGR 圖像轉灰度
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 二值圖像處理
r, b = cv.threshold(gray_img, 127, 255, cv.THRESH_BINARY_INV)

# 显示圖像
cv.imshow("src", src)
cv.imshow("result", b)

# 等待显示
cv.waitKey(0)
cv.destroyAllWindows()

從圖像上可以看到，顏色和上面的二值圖像正好相反，大部分的位置都變成了白色。

截斷閾值化

這種方法還是需要先選定一個閾值 T ，圖像中大於該閾值的像素點被設定為該閾值，小於該閾值的保持不變。

完整代碼如下：

import cv2 as cv

src = cv.imread("maliao.jpg")

# BGR 圖像轉灰度
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 二值圖像處理
r, b = cv.threshold(gray_img, 127, 255, cv.THRESH_TRUNC)

# 显示圖像
cv.imshow("src", src)
cv.imshow("result", b)

# 等待显示
cv.waitKey(0)
cv.destroyAllWindows()

這種方式實際上是把圖片比較亮的像素處理成為閾值，其他部分保持不變。

閾值化為 0

這種方式還是需要先選定一個閾值 T ，將小於 T 的像素點設置為 0 黑色，其他的保持不變。

完整代碼如下：

import cv2 as cv

src = cv.imread("maliao.jpg")

# BGR 圖像轉灰度
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 二值圖像處理
r, b = cv.threshold(gray_img, 127, 255, cv.THRESH_TOZERO)

# 显示圖像
cv.imshow("src", src)
cv.imshow("result", b)

# 等待显示
cv.waitKey(0)
cv.destroyAllWindows()

這個方法是亮的部分不改，把比較暗的部分修改為 0 。

反閾值化為 0

這個和前面的反二值圖像很像，同樣是反閾值化為 0 ，將大於等於 T 的像素點變為 0 ，其餘保持不變。

完整代碼如下：

import cv2 as cv

src = cv.imread("maliao.jpg")

# BGR 圖像轉灰度
gray_img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 二值圖像處理
r, b = cv.threshold(gray_img, 127, 255, cv.THRESH_TOZERO_INV)

# 显示圖像
cv.imshow("src", src)
cv.imshow("result", b)

# 等待显示
cv.waitKey(0)
cv.destroyAllWindows()

這個方法是暗的部分不改，把比較亮的部分修改為 0 。

全家福

接下來還是給這幾種閾值處理后的圖像來個全家福，讓大家能有一個直觀的感受，代碼我也給出來，如下：

import cv2 as cv
import matplotlib.pyplot as plt

# 讀取圖像
img=cv.imread('maliao.jpg')
lenna_img = cv.cvtColor(img,cv.COLOR_BGR2RGB)
gray_img=cv.cvtColor(img,cv.COLOR_BGR2GRAY)

# 閾值化處理
ret1, thresh1=cv.threshold(gray_img, 127, 255, cv.THRESH_BINARY)
ret2, thresh2=cv.threshold(gray_img, 127, 255, cv.THRESH_BINARY_INV)
ret3, thresh3=cv.threshold(gray_img, 127, 255, cv.THRESH_TRUNC)
ret4, thresh4=cv.threshold(gray_img, 127, 255, cv.THRESH_TOZERO)
ret5, thresh5=cv.threshold(gray_img, 127, 255, cv.THRESH_TOZERO_INV)

# 显示結果
titles = ['Gray Img','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
images = [gray_img, thresh1, thresh2, thresh3, thresh4, thresh5]

# matplotlib 繪圖
for i in range(6):
   plt.subplot(2, 3, i+1), plt.imshow(images[i],'gray')
   plt.title(titles[i])
   plt.xticks([]),plt.yticks([])

plt.show()

示例代碼

如果有需要獲取源碼的同學可以在公眾號回復「OpenCV」進行獲取。

參考

https://blog.csdn.net/Eastmount/article/details/83548652

http://www.woshicver.com/

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

※回頭車貨運收費標準

這兩年來，向我提問的人真的可以稱得上是不計其數了。哎呀，一不小心又用了個成語，裝逼在無形當中啊。雖然有點誇張，但說真的不算少了，請摸着良心問問，你是不是就問過？

但我特別討厭一種行為，就是用手機拍電腦屏幕的照片來提問。為什麼這麼說呢？請你立刻現在馬上拿起手機自己拍張照試試。如果相機不給力，屏幕像素又低，我的天吶，看這種照片上的代碼真的是痛苦啊！

鑒於此，我在群里三番五次提醒過，請用截屏，不要用手機拍照！但隔三差五還是有人這樣照干不誤，我很生氣，真的。

你提問，肯定想要得到回答，對吧？如果你用心，那回答的人也就會用心，即便是你的問題石沉大海了，那也是對自己的一種負責任啊。

在提問題的時候，你應該做好充分的準備：

• 用足夠多的細節來描述問題發生的場景，你想得到什麼樣的答案？
• 在求助之前，你做了哪些努力？研究過了嗎？得到了一些線索嗎？

那可能有些人會不服氣，拋下一句狠話：“你這大佬也太不負責任了吧？我就是沒有找到答案才過來找你的啊？我努力了呀？”

冷靜一下哈，提個問題你脾氣這麼大，這麼焦躁，怎麼可能得到答案，對不對？

讓你做準備不是我在逃避責任，而是在教你，教會你自己怎麼解決問題。就拿我來說吧，我已經很少向別人提問題了，除了那隻橡皮鴨。

有生以來，我遇到最痛苦的一個問題就是“可學上往”（寫錯別字，我是認真的），真的，當時我問遍了所有我能問的群，我能問的人，因為這個問題很無解，你了解的。

在向別人求助之前，可行的解決方案就是去問度娘，對吧，但度娘又怎麼會告訴答案呢。有些好心的同行會扔一句“VVPPNN”，然後我就搜啊搜——搜不到答案。

大概折騰了兩周的時間，還是青銅時代群里的一位小夥伴告訴了我答案。由於最近風聲緊，我就不提了。不過，我需要坦誠一句，我“可學上往”純粹是為了寫技術文章用（偶爾 1024 下，不騙你），因為有時候，一些知識點，我自己還沒有掌握，必須得先學習一下，然後才能輸出給讀者。

但度娘有時候給的答案，真的是讓你懷疑人生，那些狗屁不是的帖子它的搜索結果里全都有。但骨骼這方面做得真的是不錯，有一說一。

（這篇文章寫了不少錯別字，不要怪我，我也是被逼的，忍耐一下，看不懂的地方就 YY 一下）

為什麼我很少提問題了呢？

• 我碰到了一個問題；
• 我自己研究了一會，沒找到答案；
• 我決定還是骨骼吧；
• 我把關鍵詞扔在搜索框里，答案好像還沒找到；
• 我看了很多帖子，好像答案完全不着邊；
• 我把問題重新梳理了一遍，準備找技術比我還好的朋友提問；
• 10 分鐘過去后，我寫下了一百個字，感覺問題已經描述得很清楚了，在好友列表裡準備找朋友了；
• 突然，我發現好像我搜索的關鍵詞不太對，於是我就換了一個，又換了一個，抱着試一試的心態，結果真的找到了想要的答案。

不知道你有沒有遇到這樣的情況？反正我真的是經歷了無數次。有時候，答案找不到，我都着急得想捶爆鍵盤了，甚至狠狠地在桌子上捶了一拳，疼痛的感覺讓我冷靜下來。

於是我想到了那隻橡皮鴨，我在心裏對它說：“為什麼這台服務器上的首頁打開時間需要一分多鍾，而另外一台服務器上只需要不到三秒鐘？”

“那你有沒有對比兩台服務器有什麼不同嗎？”橡皮鴨開口回答道。

“比對了呀，完全一樣啊，代碼一樣，只是說參數不一樣，war 包也一樣，都用的 Tomcat 啊。”我憤憤不平地說。

“操作系統一樣嗎？”橡皮鴨耐心地開導着我。

“不太一樣，一台是 Windows Server，一台是 CentOS。”我回答道。

“那你有沒有想過把 Windows Server 那台也換成是 CentOS？”橡皮鴨依然很冷靜。

“不會吧，就因為操作系統不同，首頁打開速度差別就會這麼大？”

“你試試唄，把環境備份下，反正現在切換一下操作系統又不麻煩。”

“好的，聽你的，橡皮鴨。”

一個小時后，神奇的事情發生了，原來問題真的是因為 Windows Server 啊！果然不如 Linux 靠譜啊！

以上就是三年前我真實經歷過的，當時有一台遺留的 Windows Server，我就沒想着把操作系統換成是 Linux 的，然後同樣的 war 包放上去后，首頁打開速度超慢，我嘗試過對首頁加上緩存，減少 JavaScript、CSS 文件的大小，對它們進行壓縮，甚至減少了從後台獲取數據的量，但所有的嘗試都於事無補。

最後，真的是橡皮鴨幫助到了我。當你把自己完全投入到一種假想當中，去問一個透徹而詳盡的問題時，答案真的會悄無聲息地找上門來。

大多數情況下，並不是因為我們的知識庫儲備不足，而是我們尋找問題的方向發生了偏離，一旦我們意識到了這種錯誤，問題也就不再是問題。

當然了，當你嘗盡一切辦法，仍然找不到答案的話，找大牛、找朋友、找同事、找社群，不要臉地提問吧，別怕自己受到打擊，別怕問題無人解答，你要做的是，把問題梳理得越來越清晰，也許答案就在你那裡。

如果覺得文章對你有點幫助，請微信搜索「 沉默王二 」第一時間閱讀。回復關鍵字「簡歷」更有一份技術大佬整理的優質簡歷模板，助你一臂之力。

本文已收錄 GitHub，傳送門~ ，裏面更有大廠面試完整考點，歡迎 Star。

我是沉默王二，一枚有顏值卻靠才華苟且的程序員。關注即可提升學習效率，別忘了三連啊，點贊、收藏、留言，我不挑，嘻嘻。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

前言

相信大部分開發人員，或多或少都看過或寫過併發編程的代碼。併發關鍵字除了Synchronized，還有另一大分支Atomic。如果大家沒聽過沒用過先看基礎篇，如果聽過用過，請滑至底部看進階篇，深入源碼分析。

提出問題：int線程安全嗎？

看過Synchronized相關文章的小夥伴應該知道其是不安全的，再次用代碼應驗下其不安全性：

public class testInt {
    static int number = 0;

    public static void main(String[] args) throws Exception {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    number = number+1;
                }
            }
        };

        Thread t1 = new Thread(runnable);
        t1.start();
        Thread t2 = new Thread(runnable);
        t2.start();

        t1.join();
        t2.join();
        System.out.println("number:" + number);
    }
}

運行結果：

​

在上面的例子中，我們定義一個初始值為0的靜態變量number，再新建並運行兩個線程讓其各執行10萬次的自增操作，如果他是線程安全的，應該兩個線程執行后結果為20萬，但是我們發現最終的結果是小於20萬的，即說明他是不安全的。

在之前Synchronized那篇文章中說過，可以在number=number+1這句代碼上下加Synchronized關鍵字實現線程安全。但是其對資源的開銷較大，所以我們今天再看下另外一種實現線程安全的方法Atomic。

Atomic基礎篇分界線

原子整數（基礎類型）

整體介紹

Atomic是jdk提供的一系列包的總稱，這個大家族包括原子整數（AtomicInteger,AtomicLong,AtomicBoolean），原子引用（AtomicReference,AtomicStampedReference,AtomicMarkableReference），原子數組(AtomicIntegerArray,AtomicLongArray,AtomicReferenceArray)，更新器（AtomicIntegerFieldUpdater,AtomicLongFieldUpdater,AtomicReferenceFieldUpdater）。

​

AtomicInteger

AtomicInteger，AtomicBoolean，AtomicLong三者功能類似，咱就以AtomicInteger為主分析原子類。

先看下有哪些API，及其他們具體啥功能:

public class testInt {

    public static void main(String[] args) {
        //定義AtomicInteger類型的變量，值為1
        AtomicInteger i = new AtomicInteger(1);
        //incrementAndGet方法先新增1再返回，所以打印2，此時i為2
        System.out.println(i.incrementAndGet());
        //getAndIncrement方法先返回值再新增1，所以打印2，此時i為3
        System.out.println(i.getAndIncrement());
        //get方法返回當前i值，所以打印3，此時i為3
        System.out.println(i.get());
        //參數為正數即新增，getAndAdd方法先返回值再新增666，所以打印3，此時i為669
        System.out.println(i.getAndAdd(666));
        //參數為負數即減去，getAndAdd方法先返回值再減去1，所以打印669，此時i為668
        System.out.println(i.getAndAdd(-1));
        //參數為正數即新增，addAndGet方法先新增666再返回值，所以打印1334，此時i為1334
        System.out.println(i.addAndGet(666));
        //參數為負數即減去，addAndGet方法先減去-1再返回值，所以打印1333，此時i為1333
        System.out.println(i.addAndGet(-1));
        //getAndUpdate方法IntUnaryOperator參數是一個箭頭函數，後面可以寫任何操作，所以打印1333,此時i為13331
        System.out.println(i.getAndUpdate(x -> (x * 10 + 1)));
        //最終打印i為13331
        System.out.println(i.get());
    }
} 

執行結果：

​

對上述int類型的例子改進

public class testInt {
    //1.定義初始值為0的AtomicInteger類型變量number
    static AtomicInteger number = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    //2.調用incrementAndGet方法，實現加1操作
                    number.incrementAndGet();
                }
            }
        };

        Thread t1 = new Thread(runnable);
        t1.start();
        Thread t2 = new Thread(runnable);
        t2.start();

        t1.join();
        t2.join();
        System.out.println("number:" + number.get());
    }
}

我們可以看到運行結果是正確的20萬，說明AtomicInteger的確保證了線程安全性，即在多線程的過程中，運行結果還是正確的。但是這存在一個ABA問題，下面將原子引用的時候再說，先立個flag。

​

源碼分析

我們以incrementAndGet方法為例，看下底層是如何實現的，AtomicInteger類中的incrementAndGet方法調用了Unsafe類的getAndAddInt方法。

public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

我們看下getAndAddInt方法，裏面有個循環，直接值為compareAndSwapInt返回值為true,才結束循環。這裏就不得不提CAS，這就是多線程安全性問題的解決方法。

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
}

CAS

線程1和線程2同事獲取了主內存變量值0，線程1加1並寫入主內存，現在主內存變量值1，線程2也加2並嘗試寫入主內存，這個時候是不能寫入主內存的，因為會覆蓋掉線程1的操作，具體過程如下圖。

​

CAS是在線程2嘗試寫入內存的時候，通過比較並設置（CompareAndSet）發現現在主內存當前值為1，和他剛開始讀取的值0不一樣，所以他會放棄本次修改，重新讀取主內存的最新值，然後再重試下線程2的具體邏輯操作，再次嘗試寫入主內存。如果這時候線程1，再次對主內存進行了修改，線程2發現現在主內存的值又和預期不一樣，所以將放棄本次修改，再次讀取主內存最新值，再次重試並嘗試寫入主內存。我們可以發現這是一個重複比較的過程，即直到和預期初始值一樣，才會寫入主內存，否則將一直讀取重試的循環。這就是上面for循環的意義。

CAS的實現實際上利用了CPU指令來實現的，如果操作系統不支持CAS，還是會加鎖的，如果操作系統支持CAS，則使用原子性的CPU指令。

原子引用

在日常使用中，我們不止對上述基本類型進行原子操作，而是需要對一些複雜類型進行原子操作，所以需要AtomicReference。

不安全實現

先看不安全的BigDecimal類型：

public class testReference {
    static BigDecimal number = BigDecimal.ZERO;

    public static void main(String[] args) throws Exception {

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                   number=number.add(BigDecimal.ONE);
                }
            }
        };

        Thread t1 = new Thread(runnable);
        t1.start();

        Thread t2 = new Thread(runnable);
        t2.start();

        t1.join();
        t2.join();

        System.out.println(number);
    }
} 

運行結果如下圖，我們可以看到兩個線程，自循環1000次加1操作，最終結果應該是2000，可是結果小於2000。

​

安全實現-使用CAS

public class testReference {
    //定義AtomicReference類型BigDecimal變量
    static AtomicReference<BigDecimal> number = new AtomicReference<BigDecimal>(BigDecimal.ZERO);

    public static void main(String[] args) throws Exception {

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    //手動寫循環+CAS判斷
                    while(true){
                        BigDecimal pre=number.get();
                        BigDecimal next=number.get().add(BigDecimal.ONE);
                      if(number.compareAndSet(pre,next))  {
                          break;
                      }
                    }
                }
            }
        };

        Thread t1 = new Thread(runnable);
        t1.start();

        Thread t2 = new Thread(runnable);
        t2.start();

        t1.join();
        t2.join();

        System.out.println(number.get());

    }
}

運行結果如下：

​

ABA問題及解決

在上面CAS過程中，是通過值比較來知曉是不是能夠更新成功，那如果線程1先加1再減1，這樣主內存還是原來的值，即線程2還是可以更新成功的。但是這樣邏輯錯了，線程1已經發生了修改，線程2不能直接更新成功。

​

代碼：

public class testInt {

    static AtomicInteger number = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {


        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = number.get();
                System.out.println("開始number:" + a);
                try {
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(number.compareAndSet(a, a++));


            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("開始增加操作");
                int a = number.incrementAndGet();
                System.out.println("當前number:" + a);
                int b = number.decrementAndGet();
                System.out.println("當前number:" + b);
            }
        });
        t2.start();

        t1.join();
        t2.join();
    }
} 

我們看線程2對其進行了一系列操作，但是最後打印了還是true，表示可以更新成功的。這顯然不對。

​

那我們可以使用AtomicStampedReference，為其添加一個版本號。線程1在剛開始讀取主內存的時候，獲取到值為0，版本為1，線程2也獲取到這兩個值，線程1進行加1，減1的操作的時候，版本各加1，現在主內存的值為0，版本為2，而線程2還拿着預計值為0，版本為1的數據嘗試寫入主內存，這個時候因版本不同而更新失敗。具體我們用代碼試下：

public class testInt {

    static AtomicStampedReference<Integer> number = new AtomicStampedReference<Integer>(0, 0);

    public static void main(String[] args) throws Exception {


        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = number.getReference();
                int s = number.getStamp();
                System.out.println("開始number:" + a + ",stamp:" + s);
                try {
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(number.compareAndSet(a, a + 1, s, s + 1));


            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("開始增加操作");
                int a = number.getReference();
                int s = number.getStamp();
                number.compareAndSet(a, a + 1, s, s + 1);
                System.out.println("當前number:" + a + ",stamp:" + (s + 1));
                a = number.getReference();
                s = number.getStamp();
                number.compareAndSet(a, a - 1, s, s + 1);
                System.out.println("當前number:" + a + ",stamp:" + (s+1));
            }
        });
        t2.start();

        t1.join();
        t2.join();
    }
} 

我們可以看到每次操作都會更新stamp（版本號），在最後對比的時候不僅比較值，還比較版本號，所以是不能更新成功的，false.

​

原子數組

AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray三者類似，所以以AtomicIntegerArray為例，我們可以將下面AtomicIntegerArray看做是AtomicInteger類型的數組，其底層很類似，就不詳細寫了。

AtomicIntegerArray  array = new AtomicIntegerArray(10);
array.getAndIncrement(0);   // 將第0個元素原子地增加1

 

AtomicInteger[]  array = new AtomicInteger[10];
array[0].getAndIncrement();  // 將第0個元素原子地增加1

字段更新器和原子累加器比較簡單，這裏就不說了。 

Atomic進階篇分界線

LongAdder源碼分析

LongAdder使用

LongAdder是jdk1.8之後新加的，那為什麼要加他？這個問題，下面將回答，我們先看下如何使用。

public class testLongAdder {
    public static void main(String[] args) throws Exception {
        LongAdder number = new LongAdder();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int j = 0; j < 10000; j++) {
                    number.add(1L);
                }
            }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("number:" + number);
    }
}

我們可以看到LongAdder的使用和AtomicLong大致相同，使用兩個線程Thread1,Thread2對number值各進行一萬次的自增操作，最後的number是正確的兩萬。

​

與Atomic的對比優勢

那問題來了，既然AtomicLong能夠完成對多線程下的number進行線程安全的操作，那為什麼還要LongAdder?我們先來段代碼比較下，兩個在結果都是正確的前提下，性能方面的差距。

public class testLongAdder {
    public static void main(String[] args) {
       //1個線程，進行100萬次自增操作
        test1(1,1000000);
      //10個線程，進行100萬次自增操作
        test1(10,1000000);
     //100個線程，進行100萬次自增操作
        test1(100,1000000);
    }

    static void test1(int threadCount,int times){
        long startTime=System.currentTimeMillis();
        AtomicLong number1=new AtomicLong();
        List<Thread> threads1=new ArrayList<>();
        for(int i=0;i<threadCount;i++) {
            threads1.add(new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        number1.incrementAndGet();
                    }
                }
            }));
        }
        threads1.forEach(thread -> thread.start());
        threads1.forEach(thread ->{
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } );

        long endTime=System.currentTimeMillis();
        System.out.println("AtomicLong:"+number1+",time:"+(endTime-startTime));

        LongAdder number2=new LongAdder();
        List<Thread> threads2=new ArrayList<>();
        for(int i=0;i<threadCount;i++) {
            threads2.add(new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        number2.add(1);
                    }
                }
            }));
        }
        threads2.forEach(thread -> thread.start());
        threads2.forEach(thread ->{
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } );

        System.out.println("LongAdder:"+number2+",time:"+(System.currentTimeMillis()-endTime));

    }
} 

上述代碼對比了1個線程，10個線程，100個線程在進行100百次自增操作后，AtomicLong和LongAdder所花費的時間。通過打印語句，我們發現在最終number1和number2都正確的基礎上，LongAdder花費的時間比AtomicLong少了一個量級。

​

源碼分析

那為什麼會導致這種情況，我們就要從源碼層面分析。AtomicLong為什麼效率低？因為如果線程數量一多，尤其在高併發的情況下，比如有100個線程同時想要對對象進行操作，肯定只有一個線程會獲取到鎖，其他99個線程可能空轉，一直循環知道線程釋放鎖。如果該線程操作完畢釋放了鎖，其他99個線程再次競爭，也只有一個線程獲取鎖，另外98個線程還是空轉，直到鎖被釋放。這樣CAS操作會浪費大量資源在空轉上，從而使得AtomicLong在線程數越來越多的情況下越來越慢。

AtomicLong是多個線程對同一個value值進行操作，導致多個線程自旋次數太多，性能降低。而LongAdder在無競爭的情況，跟AtomicLong一樣，對同一個base進行操作，當出現競爭關係時則是採用化整為零的做法，從空間換時間，用一個數組cells，將一個value拆分進這個數組cells。多個線程需要同時對value進行操作時候，可以對線程id進行hash得到hash值，再根據hash值映射到這個數組cells的某個下標，再對該下標所對應的值進行自增操作。當所有線程操作完畢，將數組cells的所有值和無競爭值base都加起來作為最終結果。

​

我們先看下LongAdder裏面的字段，發現其裏面沒有，主要是在其繼承的Stripped64類中，有下面四個主要變量。

 /** CPU數量，即cells數組的最大長度*/
    static final int NCPU = Runtime.getRuntime().availableProcessors();

    /**
     *cells數組，為2的冪，2,4,8,16.....，方便以後位運算
     */
    transient volatile Cell[] cells;

    /**
     * 基值，主要用於沒有競爭的情況，通過CAS更新。
     */
    transient volatile long base;

    /**
     * 調整單元格大小（擴容），創建單元格時使用的鎖。
     */
    transient volatile int cellsBusy;

下面是add方法開始。

 public void add(long x) {
        //as：cells數組的引用
        //b：base的基礎值
        //v：期望值
        //m：cells數組大小
        //a:當前數組命中的單元
        Cell[] as; long b, v; int m; Cell a;
        //as不為空（cells已經初始化過，說明之前有其他線程對初始化）或者CAS操作不成功（線程間出現競爭）
        if ((as = cells) != null || !casBase(b = base, b + x)) {
        //初始化uncontented,true表示未競爭（因為有兩個情況，這裏先初始化，後面對其修改，就能區分這兩種情況）
        boolean uncontended = true;
        //as等於null(cells未初始化)
        //或者線程id哈希出來的下標所對應的值為空（cell等於空），getProbe() & m功能是獲取下標，底層邏輯是位運算
        //或者更新失敗為false，即發生競爭，取非就為ture
        if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getProbe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))
        //進入到if裏面，說明更新case失敗，或者更新某個cell也失敗了，或者cell為空，或者cells為空
                longAccumulate(x, null, uncontended);
        }
    }

從LongAdder調用Stripped64的longAccumulate方法，主要是初始化cells，cells的擴容，多個線程同時命中一個cell的競爭操作。

final void longAccumulate(long x, LongBinaryOperator fn,
                              boolean wasUncontended) {
        //x：add的值,fn：為null,wasUncontended：是否發生競爭，true為發生競爭，false為不發生競爭
        int h;//線程的hash值
        //如果該線程為0，即第一次進來，所以ThreadLocalRandom強制初始化線程id，再對其hash
        if ((h = getProbe()) == 0) {
            ThreadLocalRandom.current(); 
            h = getProbe();
            wasUncontended = true;
        }
        //擴容意向，為false肯定不擴容，為true可能擴容
        boolean collide = false; 
        //死循環               
        for (;;) {
            //as:cells數組的引用
            //a:當前線程命中的cell
            //n：cells的長度
            //v：當前線程命中的cell所擁有的value值
            Cell[] as; Cell a; int n; long v;
            //cells不為空
            if ((as = cells) != null && (n = as.length) > 0) {
                //當前線程命中的cell為空，下面邏輯是新增cell
                if ((a = as[(n - 1) & h]) == null) {
                    if (cellsBusy == 0) {       // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create
                        if (cellsBusy == 0 && casCellsBusy()) {
                            boolean created = false;
                            try {               // Recheck under lock
                                Cell[] rs; int m, j;
                                if ((rs = cells) != null &&
                                    (m = rs.length) > 0 &&
                                    rs[j = (m - 1) & h] == null) {
                                    rs[j] = r;
                                    created = true;
                                }
                            } finally {
                                cellsBusy = 0;
                            }
                            if (created)
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                //發生競爭
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                //沒有競爭，嘗試修改當前線程對應的cell值，成功跳出循環
                else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                             fn.applyAsLong(v, x))))
                    break;
                //如果n大於CPU最大數量，不可擴容
                else if (n >= NCPU || cells != as)
                    collide = false;            // At max size or stale
                else if (!collide)
                    collide = true;
                //獲取到了鎖，進行擴容，為2的冪，
                else if (cellsBusy == 0 && casCellsBusy()) {
                    try {
                        if (cells == as) {      // Expand table unless stale
                            Cell[] rs = new Cell[n << 1];//左移一位運算符，數量加倍
                            for (int i = 0; i < n; ++i)
                                rs[i] = as[i];
                            cells = rs;
                        }
                    } finally {
                        cellsBusy = 0;
                    }
                    collide = false;
                    continue;                   // Retry with expanded table
                }
                h = advanceProbe(h);
            }
            //cells等於空，並且獲取到鎖，開始初始化工作，創建結束釋放鎖，繼續循環
            else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
                boolean init = false;
                try {                           // Initialize table
                    if (cells == as) {
                        Cell[] rs = new Cell[2];
                        rs[h & 1] = new Cell(x);
                        cells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
            }
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }
    }

結語

結束了，撒花。這篇主要說了Atomic的一些使用，包括Atomic原子類（AtomicInteger，AtomicLong，AtomicBoolean），Atomic原子引用（AtomicReference，AtomicStampedReference），以及1.8之後LongAdder的優勢，源碼分析。過程還穿插了一些CAS，ABA問題引入和解決方式。

​

參考資料

Java多線程進階（十七）—— J.U.C之atomic框架：LongAdder

CAS原理

Java 8 Performance Improvements: LongAdder vs AtomicLong

AtomicInteger深入理解

原子操作類AtomicInteger詳解

玩轉Java併發工具，精通JUC，成為併發多面手

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※回頭車貨運收費標準

※台中搬家公司費用怎麼算?

精英型和豪華型相差10000元了，不多倒是也多出了這麼多的配置，像無鑰匙啟動、真皮坐椅、中控屏幕、氙氣大燈、自動空調等這些配置，就算自己後期去加裝也要花不少錢，況且這些配置最好還是原車帶的比較靠譜，自己加裝的東西出問題又不在質保範圍內。

朗逸的銷量雖好，但是身後也有無數強敵，其中英朗算是一個強有力的競爭對手。英朗在10月份的銷量為34629輛，1-10月份累加銷量為303116輛，這數據真的是亮瞎眼。

英朗的指導價為10.99-15.99萬，車身尺寸為4587*1798*1463mm，軸距為2640mm，英朗的車長沒有達到4600mm以上算是一個遺憾，因為同級別的車子長度都超過了4600mm，不過好在英朗的外觀設計比較大氣，同時軸距不小，所以後排空間還是比較充裕的。

英朗的中控內飾用料以硬塑料為主，這也是這個級別通常的配置，不過英朗的內飾看起來設計感十足，層次感突出，體現出了別克內飾設計的“環繞的感覺”，看起來稍顯高檔。

英朗的動力系統為1.5L 114馬力+5擋手動/6擋手自一體、1.4T 144馬力+7擋雙離合，目前英朗有九款在售車型，消費者面對這麼多的車型，肯定是有點迷茫的，所以今天小編就給大家看一下英朗的哪款車性價比最高，爭取在買車的時候買到最實惠的從車型。

1.5L車型的手動擋和自動的差價在1萬元，也就是1萬元買了一台6AT變速箱。進取型、精英型、豪華型的其它配置是一樣。

低配和次低配差價8000元，主要多了前排側氣囊、天窗、雷達等，對於那些經常吸煙或者買車必須要天窗的消費者來說，精英版還是合適的。但是對於不要求配置的消費者來說，進取型就足夠了。

精英型和豪華型相差10000元了，不多倒是也多出了這麼多的配置，像無鑰匙啟動、真皮坐椅、中控屏幕、氙氣大燈、自動空調等這些配置，就算自己後期去加裝也要花不少錢，況且這些配置最好還是原車帶的比較靠譜，自己加裝的東西出問題又不在質保範圍內。

所以豪華版是為那些比較看重配置消費者準備的。

說完了1.5L車型，接下來該說一說1.4T車型，1.4T車型有三個型號，分別是精英型、豪華型、旗艦型。其中精英型和1.5L的精英型配置相同。

所以頂配車型更多的只是為了提高自身形象，性價比較低。倒是精英和豪華型具有一定的性價比。

總結：其實我們是不怎麼建議消費者選擇雙離合車型，因為變速箱的調教還不是很完美，0-100km/h加速大約為10.2s，成績也不是很理想。所以最好的選擇就是1.5L車型，如果資金不充足進取型就可以，在乎天窗了就精英型，對配置有要求了可以選擇豪華型。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

※別再煩惱如何寫文案,掌握八大原則!

6T渦輪增壓發動機，最大功率132。4千瓦，最大扭矩265牛米，傳動系統方面只有1。6T車型是搭載7擋雙離合變速箱，2。0L和2。4L都是配備傳統的6擋手自一體，在動力的輸出上，1。6T車型前段的加速比2。0L、2。4L車型來得會更加直接，而在中後段就有種動力衰弱的感覺，在平順性方面，2。

現在年輕的消費者，在購車方面更多是注重外觀漂不漂亮，在空間上並不會像前輩們這麼注重，而更多的是強調自己個性潮流的一面，所以買車首選就是外觀夠不夠帥，今天編者就給大家推薦年輕人最愛的“三寶”

東風悅達起亞-起亞K5

指導價：15.98-24.88萬

新款K5在外觀上並沒有開刀闊斧的感覺，但在細節上做了提升，讓整車的細節、線條更為的精緻。“滿天星”的中網有一種奢華的格調，在視覺效果上非常的吸睛，在尾部方面並沒有做太多的改進，還是溜背式轎跑的設計，排氣依舊還是保留了雙邊共兩出的設計，更強調時尚、運動感。

在內飾設計上，K5更為簡潔，整个中控微微向駕駛員傾斜，能讓駕駛員在操作上更為簡單。按鍵的布局也十分平整，在做工用料上也在同級別中已經是中上的水準，整車的氛圍比上一代更加的簡約時尚。在空間方面，它也達到了B級車應有的水準，無論在腿部頭部空間都還有很大的余量，座椅的柔軟度恰到好處，在乘坐上的感受非常舒適。

K5提供2.0L、1.6T和2.0T、2.0L混動四款發動機可選，其中2.0L自然吸氣發動機配備的傳動系統為6擋手自一體在動力上更為平順，並不會有給你帶來很強的動力，適合斯斯文文的有為青年，而1.6T的渦輪增壓發動機，傳動系統配備的是7擋雙離合，在平順性不及2.0L發動機，但在動力上的響應性和油門的靈敏度會強上不少。2.0T渦輪增壓發動機在動力上的爆發更為明顯，最大功率180千瓦，最大扭矩350牛米，傳動系統配備的傳統的6擋手自一體，雖然6擋手自一體在響應性不會像雙離合那麼激進，但是因為發動機的動力性能夠足，駕駛快感也會更加直接。

北京現代-索納塔九

指導價：17.48-24.98萬

索納塔在外觀上的視覺衝擊更強，大嘴式的中網進氣格柵，有那麼有點點像奧迪的感覺，線條更為流暢、平緩，典型的韓系風格，整體外觀造型更加年輕、時尚。

在內飾上並沒有太多的花俏，而更多的是傳遞一種簡約時尚風，中控的設計十分大方得體，六邊形的銀色飾板，空調出風口有一塊長條的防碳纖維飾板點綴，營造出非常前衛的氣氛。在乘坐的空間上，完全達到了B級車應有的水準。索九有全景天窗、多功能方向盤、無鑰匙進入/啟動等豐富配置。

索納塔九提供了1.6T、2.0L和2.4L三款發動機，1.6T渦輪增壓發動機，最大功率132.4千瓦，最大扭矩265牛米，傳動系統方面只有1.6T車型是搭載7擋雙離合變速箱，2.0L和2.4L都是配備傳統的6擋手自一體，在動力的輸出上，1.6T車型前段的加速比2.0L、2.4L車型來得會更加直接，而在中後段就有種動力衰弱的感覺，在平順性方面，2.0L和2.4L車型更有優勢。

上汽通用雪佛蘭-邁銳寶

指導價：16.49-19.99萬

邁銳寶的外觀設計比上一代車型更加的精緻、車身的線條更加的飽滿，發動機微微隆起的線條，濃濃的美系的風格。前臉的設計很有層次感，大嘴式的進氣格柵，增強車頭的時尚感，整車的視覺感受，簡約但不簡單。

內飾上採用了“翼展式”中控設計，並且在一些部位用鍍鉻裝飾進行點綴，突出一定的精緻感，在按鍵的整體布局還是簡約大方，簡單而又有運動氛圍。在空間上並不是他的優勢，但在乘坐的舒適度非常高，因為底盤非常紮實，靜音也非常出眾。

邁銳寶提供了1.5T、1.6T和2.0L、2.4L四款發動機，傳動系統方面全系都配備6擋手自一體變速箱，其中1.5T車型最大功率125千瓦，最大扭矩252牛米，雖然排量小，但在動力的表現上比2.0L自然吸氣發動機更為突出。如更加追求動力的表現，1.6T、2.4L車型在輸出上更為優異，而行駛質感也非常高，底盤的調校非常紮實、從容。

編者點評：

面對競爭火熱的B級車市場，K5索納塔邁銳寶個性的風格，迎來不少年輕消費者的追捧，在外觀上和同級別的車型相比，不會顯得太平庸，而是更加的時尚動感，雖然都迎來了更新換代，但它們依然火爆。走在潮流尖端的年輕消費者來說，更加註重時尚，車的樣子要足夠的漂亮，這也是最基本的要求。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

※網頁設計最專業,超強功能平台可客製化

※別再煩惱如何寫文案,掌握八大原則!