java高並發程序設計源碼

Ⅰ java高並發是什麼意思,高並發的解釋

Java高並發是指Java程序在處理大量並發請求時，能夠保持高性能和穩定性。

高並發解釋如下：

高並發是計算機系統在處理多個請求時的一種狀態。當大量用戶同時訪問系統，或者系統需要處理的數據量急劇增加時，就會產生高並發的情況。對於Java程序來說，高並發意味著程序需要處理大量的請求並同時進行相應的操作，而不會出現性能下降、響應延遲或者系統崩潰等問題。

在Java中，實現高並發主要依賴於以下幾個關鍵技術和機制：

1. 線程管理：Java的線程池技術可以有效地管理和調度線程，避免創建過多的線程導致系統資源耗盡。

2. 並發控制：通過同步鎖、信號量等工具控制對共享資源的訪問，防止數據不一致和死鎖等問題。

3. 分布式架構：將系統分布在多個伺服器上，通過負載均衡等技術處理大量的並發請求。

4. 緩存優化：利用緩存來減少資料庫訪問等耗時操作，提高系統的響應速度。

高並發是互聯網應用的一個重要指標，特別是在一些需要實時響應的系統如電商網站、在線支付等場景中尤為重要。為了實現Java程序的高並發性能，開發者需要掌握多線程編程、並發控制等技術，並合理設計系統架構，優化代碼以實現高效、穩定的系統性能。

總的來說，Java高並發是Java程序在處理大量並發請求時表現出的高性能和穩定性的能力，它依賴於多種技術和機制來實現。對於開發者來說，掌握相關技術和合理設計系統架構是實現Java高並發的關鍵。

Ⅱ java並發包源碼怎麼讀

1. 各種同步控制工具的使用

1.1 ReentrantLock

ReentrantLock感覺上是synchronized的增強版，synchronized的特點是使用簡單，一切交給JVM去處理，但是功能上是比較薄弱的。在JDK1.5之前，ReentrantLock的性能要好於synchronized，由於對JVM進行了優化，現在的JDK版本中，兩者性能是不相上下的。如果是簡單的實現，不要刻意去使用ReentrantLock。

相比於synchronized，ReentrantLock在功能上更加豐富，它具有可重入、可中斷、可限時、公平鎖等特點。

首先我們通過一個例子來說明ReentrantLock最初步的用法：

package test;

import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0;

@Override public void run() { for (int j = 0; j < 10000000; j++)
{ lock.lock(); try
{
i++;
} finally
{ lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}

}

有兩個線程都對i進行++操作，為了保證線程安全，使用了ReentrantLock，從用法上可以看出，與synchronized相比，ReentrantLock就稍微復雜一點。因為必須在finally中進行解鎖操作，如果不在finally解鎖，有可能代碼出現異常鎖沒被釋放，而synchronized是由JVM來釋放鎖。

那麼ReentrantLock到底有哪些優秀的特點呢？

1.1.1 可重入

單線程可以重復進入，但要重復退出

lock.lock();
lock.lock();try{
i++;

}
finally{
lock.unlock();
lock.unlock();
}

由於ReentrantLock是重入鎖，所以可以反復得到相同的一把鎖，它有一個與鎖相關的獲取計數器，如果擁有鎖的某個線程再次得到鎖，那麼獲取計數器就加1，然後鎖需要被釋放兩次才能獲得真正釋放(重入鎖)。這模仿了synchronized的語義；如果線程進入由線程已經擁有的監控器保護的 synchronized 塊，就允許線程繼續進行，當線程退出第二個（或者後續）synchronized塊的時候，不釋放鎖，只有線程退出它進入的監控器保護的第一個synchronized塊時，才釋放鎖。

public class Child extends Father implements Runnable{ final static Child child = new Child();//為了保證鎖唯一
public static void main(String[] args) { for (int i = 0; i < 50; i++) { new Thread(child).start();
}
}
public synchronized void doSomething() {
System.out.println("1child.doSomething()");
doAnotherThing(); // 調用自己類中其他的synchronized方法
}
private synchronized void doAnotherThing() { super.doSomething(); // 調用父類的synchronized方法
System.out.println("3child.doAnotherThing()");
}
@Override
public void run() {
child.doSomething();
}
}class Father { public synchronized void doSomething() {
System.out.println("2father.doSomething()");
}
}

我們可以看到一個線程進入不同的synchronized方法，是不會釋放之前得到的鎖的。所以輸出還是順序輸出。所以synchronized也是重入鎖

輸出：

1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
...

1.1.2.可中斷

與synchronized不同的是，ReentrantLock對中斷是有響應的。中斷相關知識查看[高並發Java 二] 多線程基礎

普通的lock.lock()是不能響應中斷的，lock.lockInterruptibly()能夠響應中斷。

我們模擬出一個死鎖現場，然後用中斷來處理死鎖

package test;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;import java.lang.management.ThreadMXBean;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); int lock; public Test(int lock)
{ this.lock = lock;
} @Override
public void run()
{ try
{ if (lock == 1)
{
lock1.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock2.lockInterruptibly();
} else
{
lock2.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock1.lockInterruptibly();
}
} catch (Exception e)
{ // TODO: handle exception
} finally
{ if (lock1.isHeldByCurrentThread())
{
lock1.unlock();
} if (lock2.isHeldByCurrentThread())
{
lock2.unlock();
}
System.out.println(Thread.currentThread().getId() + ":線程退出");
}
} public static void main(String[] args) throws InterruptedException {
Test t1 = new Test(1);
Test t2 = new Test(2);
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
Thread.sleep(1000); //DeadlockChecker.check();
} static class DeadlockChecker
{ private final static ThreadMXBean mbean = ManagementFactory
.getThreadMXBean(); final static Runnable deadlockChecker = new Runnable()
{ @Override
public void run()
{ // TODO Auto-generated method stub
while (true)
{ long[] deadlockedThreadIds = mbean.findDeadlockedThreads(); if (deadlockedThreadIds != null)
{
ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds); for (Thread t : Thread.getAllStackTraces().keySet())
{ for (int i = 0; i < threadInfos.length; i++)
{ if(t.getId() == threadInfos[i].getThreadId())
{
t.interrupt();
}
}
}
} try
{
Thread.sleep(5000);
} catch (Exception e)
{ // TODO: handle exception
}
}

}
};
public static void check()
{
Thread t = new Thread(deadlockChecker);
t.setDaemon(true);
t.start();
}
}

}

上述代碼有可能會發生死鎖，線程1得到lock1，線程2得到lock2，然後彼此又想獲得對方的鎖。

我們用jstack查看運行上述代碼後的情況

下面舉個例子：

package test;import java.util.concurrent.CyclicBarrier;public class Test implements Runnable{ private String soldier; private final CyclicBarrier cyclic; public Test(String soldier, CyclicBarrier cyclic)
{ this.soldier = soldier; this.cyclic = cyclic;
} @Override
public void run()
{ try
{ //等待所有士兵到齊
cyclic.await();
dowork(); //等待所有士兵完成工作
cyclic.await();
} catch (Exception e)
{ // TODO Auto-generated catch block
e.printStackTrace();
}

} private void dowork()
{ // TODO Auto-generated method stub
try
{
Thread.sleep(3000);
} catch (Exception e)
{ // TODO: handle exception
}
System.out.println(soldier + ": done");
} public static class BarrierRun implements Runnable
{ boolean flag; int n; public BarrierRun(boolean flag, int n)
{ super(); this.flag = flag; this.n = n;
} @Override
public void run()
{ if (flag)
{
System.out.println(n + "個任務完成");
} else
{
System.out.println(n + "個集合完成");
flag = true;
}

}

} public static void main(String[] args)
{ final int n = 10;
Thread[] threads = new Thread[n]; boolean flag = false;
CyclicBarrier barrier = new CyclicBarrier(n, new BarrierRun(flag, n));
System.out.println("集合"); for (int i = 0; i < n; i++)
{
System.out.println(i + "報道");
threads[i] = new Thread(new Test("士兵" + i, barrier));
threads[i].start();
}
}

}

列印結果：

集合

士兵5: done士兵7: done士兵8: done士兵3: done士兵4: done士兵1: done士兵6: done士兵2: done士兵0: done士兵9: done10個任務完成

1.7 LockSupport

提供線程阻塞原語

和suspend類似

LockSupport.park();
LockSupport.unpark(t1);

與suspend相比不容易引起線程凍結

LockSupport的思想呢，和Semaphore有點相似，內部有一個許可，park的時候拿掉這個許可，unpark的時候申請這個許可。所以如果unpark在park之前，是不會發生線程凍結的。

下面的代碼是[高並發Java 二] 多線程基礎中suspend示例代碼，在使用suspend時會發生死鎖。

而使用LockSupport則不會發生死鎖。

另外

park()能夠響應中斷，但不拋出異常。中斷響應的結果是，park()函數的返回，可以從Thread.interrupted()得到中斷標志。

在JDK當中有大量地方使用到了park，當然LockSupport的實現也是使用unsafe.park()來實現的。

public static void park() { unsafe.park(false, 0L);
}

1.8 ReentrantLock 的實現

下面來介紹下ReentrantLock的實現，ReentrantLock的實現主要由3部分組成：

• CAS狀態

• 等待隊列

• park()

ReentrantLock的父類中會有一個state變數來表示同步的狀態

• /**


• * The synchronization state.


• */


• private volatile int state;



通過CAS操作來設置state來獲取鎖，如果設置成了1，則將鎖的持有者給當前線程

• final void lock() { if (compareAndSetState(0, 1))


• setExclusiveOwnerThread(Thread.currentThread()); else


• acquire(1);


• }



如果拿鎖不成功，則會做一個申請

• public final void acquire(int arg) { if (!tryAcquire(arg) &&


• acquireQueued(addWaiter(Node.EXCLUSIVE), arg))


• selfInterrupt();


• }



首先，再去申請下試試看tryAcquire，因為此時可能另一個線程已經釋放了鎖。

如果還是沒有申請到鎖，就addWaiter，意思是把自己加到等待隊列中去

其間還會有多次嘗試去申請鎖，如果還是申請不到，就會被掛起

• private final boolean parkAndCheckInterrupt() {


• LockSupport.park(this); return Thread.interrupted();


• }



同理，如果在unlock操作中，就是釋放了鎖，然後unpark，這里就不具體講了。

2. 並發容器及典型源碼分析

2.1ConcurrentHashMap

我們知道HashMap不是一個線程安全的容器，最簡單的方式使HashMap變成線程安全就是使用Collections.synchronizedMap，它是對HashMap的一個包裝

• public static Map m=Collections.synchronizedMap(new HashMap());



同理對於List，Set也提供了相似方法。

但是這種方式只適合於並發量比較小的情況。

我們來看下synchronizedMap的實現

它會將HashMap包裝在裡面，然後將HashMap的每個操作都加上synchronized。

由於每個方法都是獲取同一把鎖(mutex)，這就意味著，put和remove等操作是互斥的，大大減少了並發量。

下面來看下ConcurrentHashMap是如何實現的

在ConcurrentHashMap內部有一個Segment段，它將大的HashMap切分成若干個段（小的HashMap），然後讓數據在每一段上Hash，這樣多個線程在不同段上的Hash操作一定是線程安全的，所以只需要同步同一個段上的線程就可以了，這樣實現了鎖的分離，大大增加了並發量。

在使用ConcurrentHashMap.size時會比較麻煩，因為它要統計每個段的數據和，在這個時候，要把每一個段都加上鎖，然後再做數據統計。這個就是把鎖分離後的小小弊端，但是size方法應該是不會被高頻率調用的方法。

在實現上，不使用synchronized和lock.lock而是盡量使用trylock，同時在HashMap的實現上，也做了一點優化。這里就不提了。

2.2BlockingQueue

BlockingQueue不是一個高性能的容器。但是它是一個非常好的共享數據的容器。是典型的生產者和消費者的實現。

Ⅲ CRUD 程序員勿進JDK 源碼剖析手冊與並發編程圖冊，完美詮釋高並發

在後端程序員的中，如果你有高並發的經驗，也往往能得到比別人更多的機會。原因很簡單，高並發會涉及到各種各樣的技術問題，如介面響應超時、GC 頻繁、大數據量儲存、死鎖等等。能搞定高並發的程序員，技術深度一定不會差。

為了能大家更好地了解 Java 並發，我我前段時間特地從阿里的一位朋友手上拿到了他手寫的 JDK 源碼剖析手冊與並發編程圖冊，下面一起來看看吧：

JDK 源碼剖析手冊

基於 JDK7 和 JDK 8，對整個 Concurrent 包進行全面的源碼剖析。JDK8 中大部分並發功能的實現和 JDK 7 一樣，但新增了一些額外的特性。例如 CompletableFuture、ConcurrentHashMap 的新實現、StampedLock、LongAdder 等。

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

詳細內容展示

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

並發編程圖冊

包含大量圖文以及源碼分析幫助大家理解相關知識，藉助這些圖文，按照這個順序學習，至少可以讓你簡單入門並發。

總覽

點擊並拖拽以移動

詳細內容展示

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

點擊並拖拽以移動

由於這份資料實在是細節內容實在太多啦，所以只能把部分知識點截圖出來粗略的介紹，每個小節點裡面都有更細化的內容！如果有需要完整版的朋友可以： 一鍵三連支持一下私信我，注意回復【000】即可獲取更多免費資料！ 希望大家看完之後能夠有所收獲~