標籤: 如何寫文案

前文傳送門：

「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/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

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