2. 程式人生 > >Java 高併發快取與Guava Cache

Java 高併發快取與Guava Cache

阿新 • • 發佈：2019-01-24

一.背景

快取是我們在開發中為了提高系統的效能，把經常的訪問業務的資料第一次把處理結果先放到快取中，第二次就不用在對相同的業務資料在重新處理一遍，這樣就提高了系統的效能。快取分好幾種：

（1）本地快取。

（2）資料庫快取。

（3）分散式快取。

分散式快取比較常用的有memcached等，memcached是高效能的分散式記憶體快取伺服器，快取業務處理結果，減少資料庫訪問次數和相同複雜邏輯處理的時間，以提高動態Web應用的速度、 提高可擴充套件性。

二.本地快取在高併發下的問題以及解決

今天我們介紹的是本地快取快取，我們這邊採用java.util.concurrent.ConcurrentHashMap

來儲存，ConcurrentHashMap是一個執行緒安全的HashTable，並提供了一組和HashTable功能相同但是執行緒安全的方法，ConcurrentHashMap可以做到讀取資料不加鎖，提高了併發能力。我們先不考慮記憶體元素回收或者在儲存資料會出現記憶體溢位的情況，我們用ConcurrentHashMap模擬本地快取，當在高併發環境一下，會出現一些什麼問題？

我們這邊採用實現多個執行緒來模擬高併發場景。

第一種：我們先來看一下程式碼：


[java] view plain copy print?
  1. public class TestConcurrentHashMapCache<K,V> {
  2. private final ConcurrentHashMap<K, V> cacheMap=new ConcurrentHashMap<K,V> ();
  3. public Object getCache(K keyValue,String ThreadName){
  4. System.out.println("ThreadName getCache=============="+ThreadName);
  5. Object value=null;
  6. //從快取獲取資料
  7. value=cacheMap.get(keyValue);
  8. //如果沒有的話，把資料放到快取
  9. if(value==null){
  10. return putCache(keyValue,ThreadName);
  11. }
  12. return value;
  13. }
  14. public Object putCache(K keyValue,String ThreadName){
  15. System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
  16. //可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
  17. @SuppressWarnings("unchecked")
  18. V value=(V) "dataValue";
  19. //把資料放到快取
  20. cacheMap.put(keyValue, value);
  21. return value;
  22. }
  23. public static void main(String[] args) {
  24. final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
  25. Thread t1=new Thread(new Runnable() {
  26. @Override
  27. public void run() {
  28. System.out.println("T1======start========");
  29. Object value=TestGuaVA.getCache("key","T1");
  30. System.out.println("T1 value=============="+value);
  31. System.out.println("T1======end========");
  32. }
  33. });
  34. Thread t2=new Thread(new Runnable() {
  35. @Override
  36. public void run() {
  37. System.out.println("T2======start========");
  38. Object value=TestGuaVA.getCache("key","T2");
  39. System.out.println("T2 value=============="+value);
  40. System.out.println("T2======end========");
  41. }
  42. });
  43. Thread t3=new Thread(new Runnable() {
  44. @Override
  45. public void run() {
  46. System.out.println("T3======start========");
  47. Object value=TestGuaVA.getCache("key","T3");
  48. System.out.println("T3 value=============="+value);
  49. System.out.println("T3======end========");
  50. }
  51. });
  52. t1.start();
  53. t2.start();
  54. t3.start();
  55. }
  56. } 
public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public  Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//從快取獲取資料
		value=cacheMap.get(keyValue);
		//如果沒有的話，把資料放到快取
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
		//可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把資料放到快取
		 cacheMap.put(keyValue, value);
		return value;
	}

	
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}
我們看一下執行結果，如圖所示：

我們實現了本地快取程式碼，我們執行一下結果，發現在多執行緒時，出現了在快取裡沒有快取時，會執行一樣執行多次的業務資料並返回處理的資料，我們分析一下出現這種情況的：

（1）當執行緒T1訪問cacheMap裡面有沒有，這時根據業務到後臺處理業務資料並返回處理資料，並放入快取。

（2）當執行緒T2訪問cacheMap裡面同樣也沒有，也把根據業務到後臺處理業務資料並返回處理資料，並放入快取。

第二種：

這樣相同的業務並處理兩遍，如果在高併發的情況下相同的業務不止執行兩遍，這樣這樣跟我們當初做快取不相符合，這時我們想到了Java多執行緒時，在執行獲取快取上加上Synchronized，程式碼如下：

[java] view plain copy print?
  1. public class TestConcurrentHashMapCache<K,V> {
  2. private final ConcurrentHashMap<K, V> cacheMap=new ConcurrentHashMap<K,V> ();
  3. public <span style="color:#ff0000;">synchronized </span>Object getCache(K keyValue,String ThreadName){
  4. System.out.println("ThreadName getCache=============="+ThreadName);
  5. Object value=null;
  6. //從快取獲取資料
  7. value=cacheMap.get(keyValue);
  8. //如果沒有的話，把資料放到快取
  9. if(value==null){
  10. return putCache(keyValue,ThreadName);
  11. }
  12. return value;
  13. }
  14. public Object putCache(K keyValue,String ThreadName){
  15. System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
  16. //可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
  17. @SuppressWarnings("unchecked")
  18. V value=(V) "dataValue";
  19. //把資料放到快取
  20. cacheMap.put(keyValue, value);
  21. return value;
  22. }
  23. public static void main(String[] args) {
  24. final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
  25. Thread t1=new Thread(new Runnable() {
  26. @Override
  27. public void run() {
  28. System.out.println("T1======start========");
  29. Object value=TestGuaVA.getCache("key","T1");
  30. System.out.println("T1 value=============="+value);
  31. System.out.println("T1======end========");
  32. }
  33. });
  34. Thread t2=new Thread(new Runnable() {
  35. @Override
  36. public void run() {
  37. System.out.println("T2======start========");
  38. Object value=TestGuaVA.getCache("key","T2");
  39. System.out.println("T2 value=============="+value);
  40. System.out.println("T2======end========");
  41. }
  42. });
  43. Thread t3=new Thread(new Runnable() {
  44. @Override
  45. public void run() {
  46. System.out.println("T3======start========");
  47. Object value=TestGuaVA.getCache("key","T3");
  48. System.out.println("T3 value=============="+value);
  49. System.out.println("T3======end========");
  50. }
  51. });
  52. t1.start();
  53. t2.start();
  54. t3.start();
  55. }
  56. } 
public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public <span style="color:#ff0000;">synchronized </span>Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//從快取獲取資料
		value=cacheMap.get(keyValue);
		//如果沒有的話，把資料放到快取
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
		//可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把資料放到快取
		 cacheMap.put(keyValue, value);
		return value;
	}

	
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}
執行結果，如圖所示：

這樣就實現了序列，在高併發行時，就不會出現了第二個訪問相同業務，肯定是從快取獲取，但是加上Synchronized變成序列，這樣在高併發行時效能也下降了。

第三種：

我們為了實現效能和快取的結果，我們採用Future，因為Future在計算完成時獲取，否則會一直阻塞直到任務轉入完成狀態和ConcurrentHashMap.putIfAbsent方法，程式碼如下：

[java] view plain copy print?
  1. public class TestFutureCahe<K,V> {
  2. private final ConcurrentHashMap<K, Future<V>> cacheMap=new ConcurrentHashMap<K, Future<V>> ();
  3. public Object getCache(K keyValue,String ThreadName){
  4. Future<V> value=null;
  5. try{
  6. System.out.println("ThreadName getCache=============="+ThreadName);
  7. //從快取獲取資料
  8. value=cacheMap.get(keyValue);
  9. //如果沒有的話，把資料放到快取
  10. if(value==null){
  11. value= putCache(keyValue,ThreadName);
  12. return value.get();
  13. }
  14. return value.get();
  15. }catch (Exception e) {
  16. }
  17. return null;
  18. }
  19. public Future<V> putCache(K keyValue,final String ThreadName){
  20. // //把資料放到快取
  21. Future<V> value=null;
  22. Callable<V> callable=new Callable<V>() {
  23. @SuppressWarnings("unchecked")
  24. @Override
  25. public V call() throws Exception {
  26. //可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
  27. System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
  28. return (V) "dataValue";
  29. }
  30. };
  31. FutureTask<V> futureTask=new FutureTask<V>(callable);
  32. value=cacheMap.putIfAbsent(keyValue, futureTask);
  33. if(value==null){
  34. value=futureTask;
  35. futureTask.run();
  36. }
  37. return value;
  38. }
  39. public static void main(String[] args) {
  40. final TestFutureCahe<String,String> TestGuaVA=new TestFutureCahe<String,String>();
  41. Thread t1=new Thread(new Runnable() {
  42. @Override
  43. public void run() {
  44. System.out.println("T1======start========");
  45. Object value=TestGuaVA.getCache("key","T1");
  46. System.out.println("T1 value=============="+value);
  47. System.out.println("T1======end========");
  48. }
  49. });
  50. Thread t2=new Thread(new Runnable() {
  51. @Override
  52. public void run() {
  53. System.out.println("T2======start========");
  54. Object value=TestGuaVA.getCache("key","T2");
  55. System.out.println("T2 value=============="+value);
  56. System.out.println("T2======end========");
  57. }
  58. });
  59. Thread t3=new Thread(new Runnable() {
  60. @Override
  61. public void run() {
  62. System.out.println("T3======start========");
  63. Object value=TestGuaVA.getCache("key","T3");
  64. System.out.println("T3 value=============="+value);
  65. System.out.println("T3======end========");
  66. }
  67. });
  68. t1.start();
  69. t2.start();
  70. t3.start();
  71. }
  72. } 
public class TestFutureCahe<K,V> {
	private final ConcurrentHashMap<K, Future<V>>  cacheMap=new ConcurrentHashMap<K, Future<V>> (); 
	
	public   Object getCache(K keyValue,String ThreadName){
		Future<V> value=null;
		try{
			System.out.println("ThreadName getCache=============="+ThreadName);
			//從快取獲取資料
			value=cacheMap.get(keyValue);
			//如果沒有的話，把資料放到快取
			if(value==null){
				value= putCache(keyValue,ThreadName);
				return value.get();
			}
			return value.get();
				
		}catch (Exception e) {
		}
		return null;
	}
	
	
	public Future<V> putCache(K keyValue,final String ThreadName){
//		//把資料放到快取
		Future<V> value=null;
		Callable<V> callable=new Callable<V>() {
				@SuppressWarnings("unchecked")
				@Override
				public V call() throws Exception {
					//可以根據業務從資料庫獲取等取得資料,這邊就模擬已經獲取資料了
					System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
					return (V) "dataValue";
				}
			};
			FutureTask<V> futureTask=new FutureTask<V>(callable);
			value=cacheMap.putIfAbsent(keyValue, futureTask);
			if(value==null){
				value=futureTask;
				futureTask.run();
			}
		return value;
	}
	
	

	
	
	public static void main(String[] args) {
		final TestFutureCahe<String,String> TestGuaVA=new TestFutureCahe<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
				Object value=TestGuaVA.getCache("key","T1");
				System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
				System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
				System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}

執行緒T1或者執行緒T2訪問cacheMap，如果都沒有時，這時執行了FutureTask來完成非同步任務，假如執行緒T1執行了FutureTask，並把儲存到ConcurrentHashMap中，通過PutIfAbsent方法，因為putIfAbsent方法如果不存在key對應的值，則將value以key加入Map，否則返回key對應的舊值。這時執行緒T2進來時可以獲取Future物件，如果沒值沒關係，這時是物件的引用，等FutureTask執行完，在通過get返回。

我們問題解決了高併發訪問快取的問題，可以回收元素這些，都沒有，容易造成記憶體溢位，Google Guava Cache在這些問題方面都做得挺好的，接下來我們介紹一下。

三.Google Guava Cache的介紹和應用



http://www.java2s.com/Code/Jar/g/Downloadguava1401jar.htm 下載對應的jar包

Guava Cache與ConcurrentMap很相似，Guava Cache能設定回收，能解決在大資料記憶體溢位的問題，原始碼如下：



public class TestGuaVA<K,V> {
private Cache<K, V> cache= CacheBuilder.newBuilder() .maximumSize(2).expireAfterWrite(10, TimeUnit.MINUTES).build();
public Object getCache(K keyValue,final String ThreadName){
Object value=null;
try {
System.out.println("ThreadName getCache=============="+ThreadName);
//從快取獲取資料
value = cache.get(keyValue, new Callable<V>() {
@SuppressWarnings("unchecked")
public V call() {
System.out.println("ThreadName 執行業務資料並返回處理結果的資料（訪問資料庫等）=============="+ThreadName);
return (V) "dataValue";
}
});
} catch (ExecutionException e) {
e.printStackTrace();
}
return value;
}





public static void main(String[] args) {
final TestGuaVA<String,String> TestGuaVA=new TestGuaVA<String,String>();


Thread t1=new Thread(new Runnable() {
@Override
public void run() {

System.out.println("T1======start========");
Object value=TestGuaVA.getCache("key","T1");
System.out.println("T1 value=============="+value);
System.out.println("T1======end========");

}
});

Thread t2=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("T2======start========");
Object value=TestGuaVA.getCache("key","T2");
System.out.println("T2 value=============="+value);
System.out.println("T2======end========");

}
});

Thread t3=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("T3======start========");
Object value=TestGuaVA.getCache("key","T3");
System.out.println("T3 value=============="+value);
System.out.println("T3======end========");

}
});

t1.start();
t2.start();
t3.start();


}


}


說明：

CacheBuilder.newBuilder()後面能帶一些設定回收的方法：

（1）maximumSize(long)：設定容量大小，超過就開始回收。

（2）expireAfterAccess(long, TimeUnit)：在這個時間段內沒有被讀/寫訪問，就會被回收。

（3）expireAfterWrite(long, TimeUnit)：在這個時間段內沒有被寫訪問，就會被回收 。

(4)removalListener(RemovalListener)：監聽事件，在元素被刪除時，進行監聽。

執行結果，如圖所示：

相關推薦

Java 高併發快取與Guava Cache

一.背景 快取是我們在開發中為了提高系統的效能，把經常的訪問業務的資料第一次把處理結果先放到快取中，第二次就不用在對相同的業務資料在重新處理一遍，這樣就提高了系統的效能。快取分好幾種： （1）本地快取。 （2）資料庫快取。 （3）分散式快取。 分散式快取比較常用的有me

《深入分散式快取 》第4章Ehcache 與guava cache

一 序    本文屬於《深入分散式快取 》讀書筆記，第一章：快取為王主要介紹快取概念，以及引入快取的背景：提升使用者體驗。還介紹了快取的分類，第二章主要介紹分散式理論。個人覺得第二章可以去掉，畢竟是泛泛的介紹。還是專門去看有主題的書比較好，比如《<從PAXOS

實戰Java高併發程式設計（五、並行模式與演算法）

5.1單例模式 單例模式：是一種常用的軟體設計模式，在它的核心結構中值包含一個被稱為單例的特殊類。一個類只有一個例項，即一個類只有一個物件例項。 　對於系統中的某些類來說，只有一個例項很重要，例如，一個系統中可以存在多個列印任務，但是隻能有一個正在工作的任務；售票時，一共有100張票，可有有

Java 高併發程式設計詳解：多執行緒與架構設計

內容簡介 本書主要包含四個部分： 部分主要闡述 Thread 的基礎知識，詳細介紹執行緒的 API 使用、執行緒安全、執行緒間資料通訊，以及如何保護共享資源等內容，它是深入學習多執行緒內容的基礎。 第二部分引入了 ClassLoader，這是因為 ClassLoader 與執行緒不無關係

Java 高併發第三階段實戰---Java併發包深入解析與使用詳解

汪文君高併發程式設計第三階段01講 AtomicInteger多執行緒下測試講解. 汪文君高併發程式設計第三階段02講 AtomicInteger API詳解，以及CAS演算法詳細介紹. 汪文君高併發程式設計第三階段03講 利用CAS構造一個TryLock自定義顯式鎖. 汪文君高併發程式設計第三階段04講 利

Java高併發秒殺系統API之SSM框架整合swagger與AdminLTE

初衷與整理描述 Java高併發秒殺系統API是來源於網上教程的一個Java專案，也是我接觸Java的第一個專案。本來是一枚c#碼農，公司計劃部分業務轉java,於是我利用業務時間自學Java才有了本文，本來接觸之初聽別人說，c#要轉java很容易，我也信

Java高併發程式設計——為IO密集型應用設計執行緒數與劃分任務

文章轉自：http://www.tuicool.com/articles/fA7rMn 實際工作中的三類程式適用於以併發的形式來提速： 1. 服務程式：同時響應多個使用者請求 2. 計算密集型程式：併發計算，將問題拆分為子任務、併發執行各子任務並最終將子任務的結果彙

[java多執行緒]高併發List與Map

public static List<ThreadInfo> threads = new ArrayList&

java高併發（四）併發程式設計與執行緒安全

    程式碼有多個執行緒同時執行，而這些執行緒可能會同時運行同一段程式碼，如果每次執行的結果和單執行緒執行的

java高併發（二）併發與高併發基本概念

併發 同時擁有兩個或者多個執行緒，如果程式在單核處理器上執行，多個執行緒將交替地換入或者換出記憶體，這些執行緒是同時“存

Java高併發與多執行緒（一）-----概念

其實之前一直想專門寫一篇，單獨說一說Java的多執行緒與高併發，但是一直以來，都沒有想到能夠用什麼比較有趣的表現形式去表達出來，而且網上充斥著很多類似的部落格，有好的又不好的，有簡介的有繁瑣的，所以也一直沒寫。 但是想了想既然之前有這個想法，而且也已經好久沒有寫過部落格了，索性還是寫一寫，儘量寫的有意思一點

Java高併發與多執行緒（二）-----執行緒的實現方式

今天，我們開始Java高併發與多執行緒的第二篇，執行緒的實現方式。     通常來講，執行緒有三種基礎實現方式，一種是繼承Thread類，一種是實現Runnable介面，還有一種是實現Callable介面，當然，如果我們鋪開，擴充套件一下，會有很多種實現方式，但是歸根溯源，其實都是這幾種實

實戰Java高併發程式設計.epub

    【下載地址】 在過去單核CPU時代，單任務在一個時間點只能執行單一程式，隨著多核CPU的發展，並行程式開發就顯得尤為重要。 《實戰Java高併發程式設計》主要介紹基於Java的並行程式設計基礎、思路、方法和實戰。第一，立足於併發程式基礎，詳細介紹Ja

Java 高併發專案筆記

maven 配置與安裝 下載maven 檔案 解壓之後,將檔案移動到\Applications資料夾內 使用cd ~ 進入根目錄資料夾 用ls -a列出資料夾內的所有檔案，找到一個名稱為.bash_profile的檔案，開啟該檔案來配置環境變數 export JAVA_HOME=/Library/Jav

SpringBoot實現Java高併發秒殺系統之併發優化

秒殺系統架構的設計和優化分析，以我一個小菜雞，目前是說不出來的o(╥﹏╥)o。 因此呢，我這裡僅從本專案已經實現的優化來介紹一下： 本專案中做到了以下優化： 秒殺介面採用md5加密方式防刷。 訂單表使用聯合主鍵方式，限制一個使用者只能購買該商品一次。 配合Spring事務

2018最新實戰Java高併發程式設計

在過去單核CPU時代，單任務在一個時間點只能執行單一程式，隨著多核CPU的發展，並行程式開發就顯得尤為重要。《實戰Java高併發程式設計》主要介紹基於Java的並行程式設計基礎、思路、方法和實戰。第一，立足於併發程式基礎，詳細介紹Java中進行並行程式設計的基本方法。第二，進一步詳細介紹JDK中對並

高階java高併發，高效能，分散式，高可用，負載均衡，系統架構實戰

Java併發程式設計（一）： 併發程式設計的挑戰本文主要內容出自《Java併發程式設計的藝術》一書，是對該書內容的歸納和理解，有興趣的朋友請購買正版閱讀全部內容。 併發程式設計的目的是為了讓程式執行的更快，但是並不是啟動更多的執行緒，就能讓程式最大限度的併發執行。在進行併發程式設計時，如果希望通過多執行

JAVA高併發多執行緒必須懂的50個問題

ImportNew  首頁所有文章資訊Web架構基礎技術書籍教程Java小組工具資源  Java執行緒面試題 Top 50  2014/08/21 | 分類： 基礎技術 | 27 條評論 | 標籤： 多執行緒, 面試題  分享到： 692  本文由

高併發快取+資料庫雙寫不一致

高併發快取+資料庫雙寫不一致 最初快取不一致 情景一 先修改資料庫，再刪除快取，如果刪除快取失敗了，那麼會導致資料庫中是新資料，快取中是舊資料，資料出現不一致 解決方案 先刪除快取，再修改資料庫，如果刪除快取成功了，如果修改資料庫失敗了，那麼資料

Java高併發程式設計之synchronized關鍵字（二）

上一篇文章講了synchronized的部分關鍵要點，詳見：Java高併發程式設計之synchronized關鍵字（一） 本篇文章接著講synchronized的其他關鍵點。 在使用synchronized關鍵字的時候，不要以字串常量作為鎖定物件。看下面的例子： public class