2. 程式人生 > >《實戰Java高併發程式設計》學習總結（1）

《實戰Java高併發程式設計》學習總結（1）

阿新 • • 發佈：2018-11-27

第1章 走入並行世界

1 併發(Concurrency)和並行(Parallelism)都可以表示兩個或多個任務一起執行。但併發偏重於多個任務交替執行，而多個任務之間有可能還是序列。並行是真正意義上的“同時執行”。

2 有關並行的兩個重要定律。Amdahl定律強調當序列比例一定時，加速比是有上限的。Gustafson定律關心的是如果可被並行化的程式碼所佔比重足夠多，那麼加速比就能隨著CPU的數量線性增長。

  • Amdahl定律，它定義了序列系統並行化後的加速比的計算公式和理論上限

                       加速比定義：   加速比  =   優化前系統耗時 / 優化後系統耗時

                       

注：n表示處理器個數，T表示時間，T1表示優化前耗時，Tn表示使用n個處理器優化後的耗時。F是程式中只能序列執行的比例。

  • Gustafson定律，用於說明處理器個數，序列比例和加速比之間的關係。

                         

3 JAVA的記憶體模型(JMM)的關鍵技術點是圍繞多執行緒的原子性，可見性和有序性建立的。原子性是指一個操作是不可中斷，即使多執行緒一起執行，該操作也不會被幹擾；可見性是指一個執行緒修改了某個共享變數，其他執行緒能否立即知道該修改。有序性是指程式碼有序執行，這個是最難的，因為為了提高CPU處理效能，指令會重排，存在亂序風險。

4 java的32位系統中long型資料的讀和寫都不是原子性的，多執行緒之間會相互干擾。

 

 

 

 

 

 

第2章  Java並行程式基礎

1 執行緒是輕量級程序，是程式執行的最小單位。使用多執行緒而不是用多程序進行併發程式的設計，是因為執行緒間的切換和排程成本遠遠小於程序。

2 執行緒的基本操作

  • 新建執行緒，只要使用new關鍵字建立一個執行緒物件，並且將它start( )起來即可。

Thread t1 =  new Thread() {          

       @Override

       public void run() {

       // TODO Auto-generated method stub

                System.out.println("Hello world");

       }

};

t1.start();

注：start()會新建一個執行緒並讓這個執行緒執行run()。不要直接用run()啟動新執行緒，它只會在當前執行緒中序列執行run()中的程式碼

 

因為java是單繼承，可以採用實現介面Runnable來執行上面的步驟

public class CreateThread1 implements Runnable {

       public static void main(String[ ] args) {

              Thread t1  =  new Thread(new CreateThread1()) ;

               t1.start();

       }

       @Override

       public void run() {

       // TODO Auto-generated method stub

                System.out.println("Hello world");

       }

}

  • 終止執行緒，使用stop( )，但該函式過於暴力，容易造成資料不同步，不建議使用。
  • 執行緒中斷，在java中是一種重要的執行緒協作機制。它並不會使執行緒立即退出，而是給執行緒傳送一個通知告知目標執行緒。怎麼處理則由目標執行緒自行處理。

與執行緒中斷有關的有三個方法，如下

public  void  Thread.interrupt( )       // 中斷執行緒

public  boolean  Thread.isInterrupted( )       // 判斷是否被中斷

public static boolean  Thread.interrupted( )      // 判斷是否被中斷，並清除當前中斷狀態

# interrupte() 並沒有讓t1中斷

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

Thread t1 = new Thread(){

         @Override

         public void run() {

          // TODO Auto-generated method stub

                     while(true){

                             System.out.println("hello");

                             Thread.yield();

                      }

           }

};

t1.start();

Thread.sleep(2000);

t1.interrupt();

}

 

# isInterrupted() 讓t1中斷

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

Thread t1 = new Thread(){

         @Override

         public void run() {

          // TODO Auto-generated method stub

                     while(true){

                             if(Thread.currentThread().isInterrupted()) {      // 判斷是否有被中斷，有則退出     

                                                   System.out.println("interrupted!");

                                                   break;

                             }

                             System.out.println("hello");

                             Thread.yield();

                      }

           }

};

t1.start();

Thread.sleep(2000);

t1.interrupt();

}

注：Thread.sleep( ) 方法會讓當前執行緒休眠若干時間，如果此時有個中斷它會丟擲一個InterruptedException中斷異常。

  • 等待(wait)和通知(notify)，wait()和notify()並不是Thread類的，而是輸出Object類的。

public final void wait( ) throws InterruptedException

public final native void notify( )

執行緒A呼叫了obj.wait( )方法後，執行緒A會停止執行，進入object物件的等待佇列中轉為等待狀態。直到其他執行緒呼叫了obj.notify( )方法，從佇列中隨機選擇一個喚醒。wait( )不是隨便呼叫的，它必須包含在對應的synchronzied語句中，無論是wait( )或notify( )都需要首先獲得目標物件的一個監視器。

public class MultiThreadLong {

	final static Object object = new Object();
	public static class T1 extends Thread{
		public void run(){
			synchronized(object){
				System.out.println(System.currentTimeMillis()+": T1 start!");
				try{
					System.out.println(System.currentTimeMillis()+": T1 wait for object");
					object.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(System.currentTimeMillis()+": T1 end!");
			}
		}
	}
	public static class T2 extends Thread{
		public void run(){
			synchronized(object){
				System.out.println(System.currentTimeMillis()+": T2 start! notify one thread");
				object.notify();
				System.out.println(System.currentTimeMillis()+": T2 end!");
				try{
					Thread.sleep(2000);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
		}
	}
	public static void main(String[] args){
		Thread t1 = new T1();
		Thread t2 = new T2();
		t1.start();
		t2.start();
	}
}

輸出

1534760587264: T1 start!

1534760587264: T1 wait for object

1534760587264: T2 start! notify one thread

1534760587264: T2 end!

1534760589267: T1 end!           #  T1 並沒有立即繼續執行，而且等待T2釋放了object的鎖。所以它跟上一條日誌間隔2秒

注：Object.wait( )和Thread.sleep( )都可以讓執行緒等待若干時間，除了wait( )可以被喚醒外，wait( )會釋放目標物件的鎖。而sleep( )不會釋放任何資源。

  • 掛起(suspend)和繼續執行(resume)執行緒。被掛起(suspend)執行緒必須要等到resume( )操作後才能繼續執行。不推薦使用suspend()來掛起執行緒，因為它暫停同時不會釋放任何資源。
  • 等待執行緒結束(join)和謙讓(yield)

public final void join( ) throws InterruptedException     // 表示無限等待，會一直阻塞當前執行緒直到目標執行緒執行完畢

public final synchronized void join(long millis) throws InterruptedException  // 超過最大的等待時間millis後會自行繼續執行

public static native void yield( ) ;  // 靜態方法，一旦執行會使當前執行緒讓出CPU。讓出不代表不執行，會試著去搶CPU資源

    public volatile static int i = 0;
    public static class AddThread extends Thread{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			for(i=0;i<100000000;i++);
		}
		
	}
	public static void main(String[] args){
		AddThread at = new AddThread();
		at.start();
		try{
			at.join();
		}catch(InterruptedException e){
			
		}
		System.out.println(i);
	}

主函式中，如果不使用join()等待AddThread，輸出0。但使用join()函式後表示主執行緒願意等待AddThread執行完畢後再一起往前走。所以輸出100000000。

注：join()的本質是讓呼叫執行緒wait()在當前執行緒物件例項上，讓呼叫的執行緒在當前執行緒物件上進行等待。當執行緒執行完成後，被等待的執行緒會在退出前呼叫notifyAll( )通知所有等待的執行緒繼續執行。

3 用volatile申明變數時，表示該變數可能會被某些程式或者執行緒修改。為了確保這個變數被修改後，虛擬機器會採用一些特殊的手段保證該變數的可見性。

    static volatile int i = 0;
	public static class PlusTask implements Runnable {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			for(int k=0;k<10000;k++)
				i++;
		}
		
	}
	public static void main(String[] args) throws InterruptedException{
		Thread[] threads = new Thread[10];
		for(int i=0;i<10;i++){
			threads[i] = new Thread(new PlusTask());
			threads[i].start();
		}
		for(int i=0;i<10;i++)
			threads[i].join();
		System.out.println(i);
	}

如果 i++是原子性，最終值會是100000，但通過volatile是無法保證i++的原子性操作，所以輸出總是小於100000。

volatile能保證資料的可見性和有序性，如下所示，如果ready值沒有宣告為volatile屬性時，ready=true的賦值ReaderThread執行緒無法收到。

    private static volatile boolean ready;
	private static int number;
	
	public static class ReaderThread extends Thread{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(!ready);
			System.out.println(System.currentTimeMillis()+": "+number);
		}
		
	}
	
	public static void main(String[] args) throws InterruptedException {
		System.out.println(System.currentTimeMillis()+": 1");
		new ReaderThread().start();
		Thread.sleep(1000);
		System.out.println(System.currentTimeMillis()+": 2");
		number = 42;
		ready = true;
		Thread.sleep(1000);
		System.out.println(System.currentTimeMillis()+": 3");
	}

4 分門別類的管理：執行緒組，在一個系統中如果執行緒數量很多且功能分配明確，可以將相同功能的執行緒放在一個執行緒組中如下

public class MultiThreadLong implements Runnable {

	public static void main(String[] args){
		ThreadGroup tg = new ThreadGroup("PrintGroup");  // 建立一個"PrintGroup"的執行緒組
		Thread t1 = new Thread(tg,new MultiThreadLong(),"T1");
		Thread t2 = new Thread(tg,new MultiThreadLong(),"T2");
		t1.start();
		t2.start();
		System.out.println(tg.activeCount()); // 獲得活動執行緒的總數
		tg.list();  // 列印執行緒組的所有執行緒資訊

	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		String groupAndName = Thread.currentThread().getThreadGroup().getName()
				+"-"+Thread.currentThread().getName();
		while(true){
			System.out.println("I am "+groupAndName);
			try{
				Thread.sleep(3000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	
}

輸出

2

I am PrintGroup-T1

I am PrintGroup-T2

java.lang.ThreadGroup[name=PrintGroup,maxpri=10]

    Thread[T1,5,PrintGroup]

    Thread[T2,5,PrintGroup]

I am PrintGroup-T1

I am PrintGroup-T2

I am PrintGroup-T1

I am PrintGroup-T2

I am PrintGroup-T1

I am PrintGroup-T2

I am PrintGroup-T1

I am PrintGroup-T2

I am PrintGroup-T1

I am PrintGroup-T2

5 駐守後臺：守護執行緒(Daemon)，系統的守護者，在後臺默默地完成一些系統性的服務，比如垃圾回收執行緒，JIT執行緒等。

public class DaemonDemo {
	public static class DaemonT extends Thread{

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true){
				System.out.println("I am alive");
				try{
					Thread.sleep(1000);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
		}
		
	}
	public static void main(String[] args) throws InterruptedException{
		Thread t = new DaemonT();
		t.setDaemon(true);  // 設定為守護執行緒，但必須要在start()呼叫之前
		t.start();
		Thread.sleep(2000);
	}
}

t被設定為守護執行緒，系統只有主執行緒main為使用者執行緒，因此在main執行緒休眠2秒後退出時，整個程式也會結束，t也結束。如果不把執行緒t設定為守護執行緒，main執行緒結束後，t執行緒還好不停地列印，永遠不會結束。

6 java中的執行緒都可以有自己的優先順序，使用1到10表示優先順序，有三個內建的靜態標量表示：

  • public final static int MIN_PRIORITY = 1    // 優先順序最低
  • public final static int NORM_PRIORITY = 5
  • public final static int MAX_PRIORITY = 10   // 優先順序最高
public class PriorityDemo {

	public static class HightPriority extends Thread{
		static int count = 0;

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true){
				synchronized(PriorityDemo.class){
					count++;
					if(count > 10000000){
						System.out.println("HightPriority is complete");
						break;
					}
				}
			}
		}
		
	}
	public static class LowPriority extends Thread{
		static int count = 0;

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true){
				synchronized(PriorityDemo.class){
					count++;
					if(count > 10000000){
						System.out.println("LowPriority is complete");
						break;
					}
				}
			}
		}
	}
	public static void main(String[] args){
		Thread high = new HightPriority();
		LowPriority low = new LowPriority();
		high.setPriority(Thread.MAX_PRIORITY);  // 設定優先順序
		low.setPriority(Thread.MIN_PRIORITY);   // 設定優先順序
		low.start();
		high.start();
	}
}

high優先順序高，所以在多數情況下會比low快，但不是每次都比low快

7 關鍵字synchronized的作用是實現執行緒間的同步。它的工作是對同步的程式碼加鎖，使得每次只有一個執行緒進入同步塊。主要有如下幾種用法

  • 指定加鎖物件：對給定的物件加鎖，進入同步程式碼前要獲得給定物件的鎖
  • 直接作用於例項方法：相當於對當前例項加鎖，進入同步程式碼前要獲得當前例項的鎖
  • 直接作用於靜態方法：相當於對當前類加鎖，進入同步程式碼前要獲得當前類的鎖
public class AccountingVol implements Runnable {

	static AccountingVol instance = new AccountingVol();
	static int i = 0;
	public static void increase(){
		i++;
	}
	public synchronized void increase2(){   // 第一種方法，函式定義為同步
		i++;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int j=0;j<10000000;j++){
			// 第二種方法，物件定義為同步
			synchronized(instance){
				i++;
			}
			
			//increase2();
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(instance);
		Thread t2 = new Thread(instance);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}

}

8 ArrayList是一個執行緒不安全的容器。如果多執行緒使用ArrayList可能會導致程式出錯。可以使用執行緒安全的Vector來代替ArrayList

9 HashMap也是執行緒不安全，多執行緒訪問HashMap也會導致程式出錯。可以使用ConcurrentHashMap來代替HashMap

10 一個錯誤的加鎖，如下所示，給i加鎖，但因為i是Integer物件，是不變物件，每次的值變其實都是新建一個Integer物件，即鎖加在了不同的物件上。可以修改為synchronized(instance)即可

public class BadLockOnInteger implements Runnable {

	public static Integer i = 0;
	static BadLockOnInteger instance = new BadLockOnInteger();
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int j=0;j<10000000;j++){
			synchronized(i){
				i++;
			}
		}
	}
	public static void main(String[] args) throws InterruptedException{
		Thread t1 = new Thread(instance);
		Thread t2 = new Thread(instance);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}

}

 

相關推薦

Java高併發程式設計學習筆記（三）：Java記憶體模型和執行緒安全

文章目錄 原子性 有序性 可見性 – 編譯器優化 – 硬體優化(如寫吸收，批操作) Java虛擬機器層面的可見性 Happen-Before規則（先行發生） 程式順序原則: volat

《實戰Java高併發程式設計》學習總結（3）

第6章  java8與併發 1 顯式函式指函式與外界交換資料的唯一渠道就是引數和返回值，顯式函式不會去讀取或者修改函式的外部狀態。這樣的函式對於除錯和排錯是有益的。 2 函數語言程式設計式申明式的程式設計方式。而命令式則喜歡大量使用可變物件和指令。如下 // 指令式程式設計 p

《實戰Java高併發程式設計》學習總結（2）

第3章  JDK併發包 1 synchronized的功能擴充套件：重入鎖。使用java.util.concurrent.locks.ReentrantLock類來實現。 import java.util.concurrent.locks.ReentrantLock; publi

《實戰Java高併發程式設計》學習總結（1）

第1章 走入並行世界 1 併發(Concurrency)和並行(Parallelism)都可以表示兩個或多個任務一起執行。但併發偏重於多個任務交替執行，而多個任務之間有可能還是序列。並行是真正意義上的“同時執行”。 2 有關並行的兩個重要定律。Amdahl定律強調當序列比例一定時，加速比是有

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

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

實戰Java高併發程式設計（四、鎖的優化及注意事項）

在多核時代，使用多執行緒可以明顯地提升系統的效能。但事實上，使用多執行緒會額外增加系統的開銷。對於單任務或單執行緒的應用來說，其主要資源消耗在任務本身。對於多執行緒來說，系統除了處理功能需求外，還需要維護多執行緒環境特有的資訊，如執行緒本身的元資料，執行緒的排程，執行緒上下文的切換等。 4.1有

實戰Java高併發程式設計（3.2 執行緒池）

1.Executor jdk提供了一套Executor框架，本質上是一個執行緒池。 newFixedThreadPool()方法：該方法返回一個固定數量的執行緒池。該執行緒池中的執行緒數量始終不變，當有一個新任務提交時，執行緒池中若有空閒執行緒，則立即執行，若沒有，則任務會暫存在一個任

實戰Java高併發程式設計（3.1同步控制）

3.1重入鎖 重入鎖使用java.util.concurrent.locks.ReentrantLock來實現 public class Test implements Runnable { public static ReentrantLock lock = new Reentr

頂級架構師學習——第二階段：實戰Java高併發程式設計

1、什麼是並行？ 並行處理（ParallelProcessing）是計算機系統中能同時執行兩個或更多個處理機的一種計算方法。處理機可同時工作於同一程式的不同方面。並行處理的主要目的是節省大型和複雜問題的解決時間。 2、為什麼需要並行？ 平行計算只有在  影象處理  和 

實戰Java高併發程式設計（一）走進併發世界

阻塞（blocking）一個執行緒是阻塞的，那麼其它的執行緒釋放資源之前，當前執行緒無法繼續執行。使用synchronized或者重入鎖會使執行緒這是。 無飢餓（starvation-free）：對於非公平的鎖來說，系統允許高優先順序的執行緒插隊，會造成飢餓；而公平的鎖則不會造成飢餓。 無障礙（obstruc

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

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

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

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

實戰java高併發程式設計之CountDownLatch原始碼分析

首先看第一個！ CountDownLatch 使用場景 CountDownLatch類是常見的併發同步控制類，適用於某一執行緒的執行在其他多個執行緒執行完成之後，比如火箭發射前需要各項指標檢查，只有當各項指標檢查完才能發射，再比如解析多個excel文件，只有當

Java多執行緒程式設計學習總結（二）

  （尊重勞動成果，轉載請註明出處：https://blog.csdn.net/qq_25827845/article/details/84894463冷血之心的部落格） 系列文章： Java多執行緒程式設計學習總結（一） Java多執行緒程式設計學習總結（二） 前

實戰java高併發程式設計之ReentrantReadWriteLoc原始碼分析

前面分析了併發工具類CountDownLatch和CyclicBarrier，本文分享分析比較重要的ReentrantReadWriteLock。 使用場景 以前的同步方式需要對讀、寫操作進行同步，讀讀之間，讀寫之間，寫寫之間等；工程師們發現讀讀之間並不會影響資

Java 多執行緒程式設計學習總結（一）

定義篇 程序(Process)和執行緒(Thread) 怎樣實現多工處理（Multitasking）？ 多工處理是同時執行多個任務的過程。我們使用多工處理來利用 CPU。可通過兩種方式實現多工處理: · 基於程序的多工 (多重處理) · 基於執行緒的多工處理

java 併發程式設計學習筆記（一）之 併發基礎

                                              併發基礎 併發小測試 java.util.concurrent.Semaphore 類 public class SemTest { /** * Se

java 併發程式設計學習筆記（一）之 基礎框架搭建和併發模擬工具，程式碼

                                基礎框架搭建和併發模擬工具,程式碼 （1）基礎框架搭建 （2）併發模擬 （3）CountDownLatch  通常用來 保證 幾個執行緒執行完成之後，再執行其他的程式碼 Semaphore

實戰java高併發程式設計 原始碼 source code

@rover這個是C++模板 --胡滿超 stack<Postion> path__;這個裡面 ”<> “符號是什麼意思？我在C++語言裡面沒見過呢？ 初學者，大神勿噴。

java 併發程式設計學習筆記（九）多執行緒併發拓展

                                         多執行緒