2. 程式人生 > >java多執行緒--練習題總結

java多執行緒--練習題總結

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

目錄

 

練題1:編寫程式實現,子執行緒迴圈3次,接著主執行緒迴圈5次,接著再子執行緒迴圈3次,主執行緒迴圈5次,如此反覆,迴圈3次.

練習題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1.

練習題3:自己編寫程式碼,實現生產者-消費者模型功能.內容自由發揮,只需要表達思想.

練習題4：現在有T1、T2、T3三個執行緒，你怎樣保證T2在T1執行完後執行，T3在T2執行完後執行？

練題1:編寫程式實現,子執行緒迴圈3次,接著主執行緒迴圈5次,接著再子執行緒迴圈3次,主執行緒迴圈5次,如此反覆,迴圈3次.

第一種實現方式：使用synchronized關鍵字

package com.lianxi;

public class ThreadMain2 {
 
	public static void main(String[] args) { 
		final ThreadFunction2 f2 = new ThreadFunction2();
		
		// 子執行緒迴圈3次
		new Thread(new Runnable(){
			public void run(){
				for(int i=0;i<3;i++){
					f2.subFunction();
				}
			}
		}).start();
		
		// 主執行緒迴圈3次
		for(int i=0;i<3;i++){
			f2.mainFunction();
		} 
	}

}

 
package com.lianxi;

// 編寫功能類,實現子執行緒和主執行緒的功能
public class ThreadFunction2 {
	
	private boolean flag = false;
	
	// 主執行緒要實現的功能
	public synchronized void mainFunction(){
		while(!flag){
			try {
				this.wait();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			}
		}
		for(int i=0;i<5;i++){
			System.out.println("mainFunction"+i);
		} 
		this.notify();
		flag = false;
	}
	
	// 子執行緒要實現的功能
	public synchronized void subFunction(){
		while(flag){
			try {
				this.wait();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			} 
		}
		for(int i=0;i<3;i++){
			System.out.println("subFunction"+i);
		} 
		this.notify();
		flag = true;
	}

}

輸出結果：

subFunction0
subFunction1
subFunction2
mainFunction0
mainFunction1
mainFunction2
mainFunction3
mainFunction4
subFunction0
subFunction1
subFunction2
mainFunction0
mainFunction1
mainFunction2
mainFunction3
mainFunction4
subFunction0
subFunction1
subFunction2
mainFunction0
mainFunction1
mainFunction2
mainFunction3
mainFunction4

第二種實現方式：使用 lock 鎖和 Condition 介面

package com.lianxi;

public class ThreadMain {
 
	public static void main(String[] args) { 
		final ThreadFunction f = new ThreadFunction();
		
		// 子執行緒迴圈3次
		new Thread(new Runnable(){
			public void run(){
		        for(int i=0;i<3;i++){
		        	f.subFunction();
		        }
			}
		}).start();
		
		// 主執行緒迴圈3次
		for(int i=0;i<3;i++){
        	f.mainFunction();
        }

	}

}

package com.lianxi;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 編寫功能類,實現子執行緒和主執行緒的功能
public class ThreadFunction extends Thread{
	
	private boolean flag = false;
	Lock lock = new ReentrantLock();
	Condition con = lock.newCondition();
	
    // 主執行緒要實現的功能
	public void mainFunction(){ 
		System.out.println("1.主執行緒開始"+" -- flag="+flag);
		lock.lock();
		try{ 
			while(!flag){ 
				try {
					System.out.println("2.主執行緒等待"+" -- flag="+flag);
					con.await();   // 使當前執行緒加入 await() 等待佇列中，並釋放當鎖，當其他執行緒呼叫signal()會重新請求鎖。與Object.wait()類似。
				} catch (InterruptedException e) { 
					e.printStackTrace();
				} 
			}  
			System.out.println("7.主執行緒開始迴圈5次"+" -- flag="+flag);
			for(int i=0;i<5;i++){ 
				System.out.println("mainFunction"+i+" -- flag="+flag); 
			}
			flag = false;
			System.out.println("8.喚醒子執行緒"+" -- flag="+flag);
			con.signal();  // 喚醒一個在 await()等待佇列中的執行緒。與Object.notify()相似
		}finally{
			lock.unlock(); 
		}
		 
		
		
	}
	
    // 子執行緒要實現的功能
	public void subFunction(){ 
		System.out.println("3.子執行緒開始"+" -- flag="+flag);
		lock.lock(); 
		try{
			while(flag){
				try {
					System.out.println("6.子執行緒等待"+" -- flag="+flag);
					con.await();  // 使當前執行緒加入 await() 等待佇列中，並釋放當鎖，當其他執行緒呼叫signal()會重新請求鎖。與Object.wait()類似。
				} catch (InterruptedException e) { 
					e.printStackTrace();
				}  
			}
			System.out.println("4.子執行緒開始迴圈3次"+" -- flag="+flag);
			for(int i=0;i<3;i++){
				System.out.println("subFunction"+i+" -- flag="+flag);
			}
			flag = true;
			System.out.println("5.喚醒主執行緒"+" -- flag="+flag);
			con.signal(); // 喚醒一個在 await()等待佇列中的執行緒。與Object.notify()相似
		}finally{
			lock.unlock();  
		}  
	} 
}

輸出結果：

1.主執行緒開始 -- flag=false
2.主執行緒等待 -- flag=false
3.子執行緒開始 -- flag=false
4.子執行緒開始迴圈3次 -- flag=false
subFunction0 -- flag=false
subFunction1 -- flag=false
subFunction2 -- flag=false
5.喚醒主執行緒 -- flag=true
3.子執行緒開始 -- flag=true
7.主執行緒開始迴圈5次 -- flag=true
mainFunction0 -- flag=true
mainFunction1 -- flag=true
mainFunction2 -- flag=true
mainFunction3 -- flag=true
mainFunction4 -- flag=true
8.喚醒子執行緒 -- flag=false
1.主執行緒開始 -- flag=false
2.主執行緒等待 -- flag=false
4.子執行緒開始迴圈3次 -- flag=false
subFunction0 -- flag=false
subFunction1 -- flag=false
subFunction2 -- flag=false
5.喚醒主執行緒 -- flag=true
3.子執行緒開始 -- flag=true
6.子執行緒等待 -- flag=true
7.主執行緒開始迴圈5次 -- flag=true
mainFunction0 -- flag=true
mainFunction1 -- flag=true
mainFunction2 -- flag=true
mainFunction3 -- flag=true
mainFunction4 -- flag=true
8.喚醒子執行緒 -- flag=false
1.主執行緒開始 -- flag=false
2.主執行緒等待 -- flag=false
4.子執行緒開始迴圈3次 -- flag=false
subFunction0 -- flag=false
subFunction1 -- flag=false
subFunction2 -- flag=false
5.喚醒主執行緒 -- flag=true
7.主執行緒開始迴圈5次 -- flag=true
mainFunction0 -- flag=true
mainFunction1 -- flag=true
mainFunction2 -- flag=true
mainFunction3 -- flag=true
mainFunction4 -- flag=true
8.喚醒子執行緒 -- flag=false

Lock和synchronized的選擇

　　總結來說，Lock和synchronized有以下幾點不同：

　　1）Lock是一個介面，而synchronized是Java中的關鍵字，synchronized是內建的語言實現；

　　2）synchronized在發生異常時，會自動釋放執行緒佔有的鎖，因此不會導致死鎖現象發生；而Lock在發生異常時，如果沒有主動通過unLock()去釋放鎖，則很可能造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖；

　　3）Lock可以讓等待鎖的執行緒響應中斷，而synchronized卻不行，使用synchronized時，等待的執行緒會一直等待下去，不能夠響應中斷；

　　4）通過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。

　　5）Lock可以提高多個執行緒進行讀操作的效率。

　　在效能上來說，如果競爭資源不激烈，兩者的效能是差不多的，而當競爭資源非常激烈時（即有大量執行緒同時競爭），此時Lock的效能要遠遠優於synchronized。所以說，在具體使用時要根據適當情況選擇。

 

 

練習題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1.

package com.lianxi;

// 面試題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1.
public class ThreadTest { 
      
    public static void main(String[] args){ 
    	
    	final ThreadTestFunction f = new ThreadTestFunction();
    	
    	Thread t1 = new Thread(new Runnable(){
    		public void run(){
    			f.add();
    		} 
    	});
    	
    	Thread t2 = new Thread(new Runnable(){
    		public void run(){
    			f.add();
    		} 
    	});
    	
    	Thread t3 = new Thread(new Runnable(){
    		public void run(){
    			f.sub();;
    		} 
    	});
    	
    	Thread t4 = new Thread(new Runnable(){
    		public void run(){
    			f.sub();
    		} 
    	}); 
    	 
    	t1.start();
    	t2.start();
    	t3.start();
    	t4.start();
    }  
}

package com.lianxi;

public class ThreadTestFunction { 
	
	private int i=0;
	
	public synchronized void add(){
		i++;
		System.out.println(Thread.currentThread().getName()+"add:i="+i);
	}
	
	public synchronized void sub(){
		i--;
		System.out.println(Thread.currentThread().getName()+"sub:i="+i);
	}
}

輸出結果：

Thread-0add:i=1
Thread-3sub:i=0
Thread-2sub:i=-1
Thread-1add:i=0

練習題3:自己編寫程式碼,實現生產者-消費者模型功能.內容自由發揮,只需要表達思想.

package com.lianxi;

public class ThreadProductTest {

	/**
	 * 面試題3:自己編寫程式碼,實現生產者-消費者模型功能.內容自由發揮,只需要表達思想.
	 * 程式碼中,自定義一個學生類,有name和age屬性,屬於共享物件,
	 * 生產者負責為studnet物件賦值,消費者負責打印出student物件的name和age的值,
	 * 當生產者賦值完以後通知消費者來列印,消費者列印完以後,通知生產者重新設定.
	 */
	public static void main(String[] args) { 
		
		final ThreadStudent s = new ThreadStudent();
		
		// 模擬生產者執行緒類
		Thread inputThread = new Thread(new Runnable(){
			public void run(){ 
				int num = 10;
				while(num>0){
					if(num % 2 == 0){
						s.set("劉德華", 56); 
					}else{
						s.set("倉木麻衣", 36); 
					}
					num--;
				}  
			}
		},"生產者");
		
		// 模擬消費者執行緒類
		Thread outputThread = new Thread(new Runnable(){
			public void run(){  
				int num = 10;
				while(num>0){
					s.get();
					num--;
				}  
			}
		},"消費者");
		
		inputThread.start();
		outputThread.start();
	}
	 

}

package com.lianxi;

//學生實體類作為共享資源
public class ThreadStudent { 

	public String name;  // 姓名
	public int age;  // 年齡
	public boolean flag = false;  // 標記變數,判斷當前學生物件是否已建立賦值好
	
	//生產者的功能  ,為studnet物件賦值
	public synchronized void set(String name,int age){ 
		if(flag){
			try {
				this.wait();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			}
		} 
		
		this.name = name;
		this.age = age;
		System.out.println(Thread.currentThread().getName()+"  student:name="+name+",age="+age+" -- flag="+flag);
		this.flag = true;
		this.notify(); // 喚醒 消費者執行緒 
		
	}
	
	// 消費者的功能,列印sutdent物件的內容
	public synchronized void get(){ 
		if(!flag){
			try {
				this.wait();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			} 
		}
		System.out.println(Thread.currentThread().getName()+"  student:name="+name+",age="+age+" -- flag="+flag);
		
		this.flag = false;
		this.notify(); // 喚醒 生產者執行緒
		
	}

}

輸出結果：

生產者  student:name=劉德華,age=56 -- flag=false
消費者  student:name=劉德華,age=56 -- flag=true
生產者  student:name=倉木麻衣,age=36 -- flag=false
消費者  student:name=倉木麻衣,age=36 -- flag=true
生產者  student:name=劉德華,age=56 -- flag=false
消費者  student:name=劉德華,age=56 -- flag=true
生產者  student:name=倉木麻衣,age=36 -- flag=false
消費者  student:name=倉木麻衣,age=36 -- flag=true
生產者  student:name=劉德華,age=56 -- flag=false
消費者  student:name=劉德華,age=56 -- flag=true
生產者  student:name=倉木麻衣,age=36 -- flag=false
消費者  student:name=倉木麻衣,age=36 -- flag=true
生產者  student:name=劉德華,age=56 -- flag=false
消費者  student:name=劉德華,age=56 -- flag=true
生產者  student:name=倉木麻衣,age=36 -- flag=false
消費者  student:name=倉木麻衣,age=36 -- flag=true
生產者  student:name=劉德華,age=56 -- flag=false
消費者  student:name=劉德華,age=56 -- flag=true
生產者  student:name=倉木麻衣,age=36 -- flag=false
消費者  student:name=倉木麻衣,age=36 -- flag=true

練習題4：現在有T1、T2、T3三個執行緒，你怎樣保證T2在T1執行完後執行，T3在T2執行完後執行？

package com.lianxi;

import java.util.Date;

public class ThreadSortTest {

	/**
	 * 現在有T1、T2、T3三個執行緒，你怎樣保證T2在T1執行完後執行，T3在T2執行完後執行？
	 */
	public static void main(String[] args) { 
		
		Thread t1 = new Thread(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+" -- "+System.currentTimeMillis());
			} 
		},"t1");
		
		Thread t2 = new Thread(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+" -- "+System.currentTimeMillis());
			} 
		},"t2");
		
		Thread t3 = new Thread(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+" -- "+System.currentTimeMillis());
			} 
		},"t3");
		
		t1.start();
		try {
			t1.join();  // t1.join()需要等t1.start()執行之後執行才有效果
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		t2.start();
		try {
			t2.join();  // t2.join()需要等t2.start()執行之後執行才有效果
		} catch (InterruptedException e) { 
			e.printStackTrace();
		}
		t3.start();

	}

}

輸出結果：

t1 -- 1540456352889
t2 -- 1540456352889
t3 -- 1540456352890

轉載請註明出處：https://blog.csdn.net/yuzongtao/article/details/83378538

相關推薦

java多執行緒--練習題總結

目錄   練題1:編寫程式實現,子執行緒迴圈3次,接著主執行緒迴圈5次,接著再子執行緒迴圈3次,主執行緒迴圈5次,如此反覆,迴圈3次. 練習題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1. 練習題3:自己編寫程式碼,實現生產者-消費者模

#Java多執行緒知識點總結wait、notify、notifyAll

Java多執行緒 設計一個典型的場景，來闡述wait()、notify()、notifyAll()，生產消費者。 有生產者、消費者、緩衝佇列（size=10）。 生產者不停地向緩衝佇列裡放資料，一旦佇列滿了，則wait()，並notify()消費者進行處理。 消費者不停地從緩衝佇列裡

面試系列-40個Java多執行緒問題總結

前言 這篇文章主要是對多執行緒的問題進行總結的，因此羅列了40個多執行緒的問題。 這些多執行緒的問題，有些來源於各大網站、有些來源於自己的思考。可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，但是本文寫作的重心就是 所有的問題都會按照自己的理解

【Java多執行緒併發總結】Thread類的常用方法(join、yield等)---執行緒的基礎操作篇

 啟動(start)   最基本的操作，呼叫Runnable中的run方法，無返回值。 new Thread(new Test()).start(); 休眠(sleep)  使當前執行緒休眠一段時間，預設為毫秒級，最高可以精確到納秒，呼叫的方法為slee

java多執行緒知識總結

程序：一個程序包括由作業系統分配的記憶體空間，包含一個或多個執行緒。一個執行緒不能獨立的存在，它必須是程序的一部分。一個程序一直執行，直到所有的非守護執行緒都結束執行後才能結束。 多執行緒能滿足程式設計師編寫高效率的程式來達到充分利用 CPU 的目的。 詳細解釋： 程式：為了完成特定任務

Java多執行緒程式設計總結筆記——03概念與原理

作業系統中執行緒和程序的概念 現在的作業系統是多工作業系統。多執行緒是實現多工的一種方式。 程序是指一個記憶體中執行的應用程式，每個程序都有自己獨立的一塊記憶體空間，一個程序中可以啟動多個執行緒。比如在Windows系統中，一個執行的exe就是一個程序。執行

Java多執行緒程式設計總結筆記——02多執行緒基礎知識

讀解Thread類API 構造方法摘要 Thread(Runnable target) 分配新的 Thread 物件。 Thread(String name) 分配新的 Thread 物件。 方法摘要 static Thread cur

Java 多執行緒問題總結

1、多執行緒有什麼用？ （1）發揮多核CPU的優勢       隨著工業的進步，現在的筆記本、桌上型電腦乃至商用的應用伺服器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單執行緒的程式，那麼在雙核CPU上就浪費了50%，在4核

Java多執行緒程式設計總結筆記——01 Java語言的執行緒

GUI應用程式 幾乎所有的GUI應用程式都會用多執行緒。舉例來說加入現在有人在用word編輯一個比較大的文字檔案剛剛才做過單字“查詢”操作，當word進行查詢時，螢幕上會出現“停止查詢按鈕”，使用者可以隨時停止查詢。這個功能其實就用到了多執行緒。 （1）執行

Java多執行緒筆記總結

1.執行緒的三種建立方式 對比三種方式： 通過繼承Thread類實現 通過實現Runnable介面 實現Callable介面 第1種方式無法繼承其他類，第2，3種可以繼承其他類； 第2，3種方式多執行緒可以共享同一個target物件，多個執行緒處

40個Java多執行緒問題總結

前言Java多執行緒分類中寫了21篇多執行緒的文章，21篇文章的內容很多，個人認為，學習，內容越多、越雜的知識，越需要進行深刻的總結，這樣才能記憶深刻，將知識變成自己的。這篇文章主要是對多執行緒的問題進行總結的，因此羅列了40個多執行緒的問題。這些多執行緒的問題，有些來源於各大網站、有些來源於自己的思考。可能

Java多執行緒知識點總結——進階篇（八） 之 等待喚醒機制 Lock 鎖升級版

JDK1.5 中提供了多執行緒升級解決方案。 將同步 Synchronized 替換成現實 Lock 操作。 將Object中的 wait、notify、notifyAll，替換成了C

Java多執行緒知識點總結——進階篇（五）之多執行緒下的單例模式

餓漢式 餓漢式多執行緒和單執行緒的程式碼是一樣的，如下： class Single { private static final Single s = new Single(); p

java多執行緒程式設計總結(一)

為了深入學習java多執行緒程式設計，我閱讀了高洪巖老師的《Java多執行緒程式設計核心技術》這本書，不得不說，這本書的內容實在到位，這是一本值得推薦閱讀的書，我在閱讀完電子版後還特意去圖書館找到了這本書的紙質版，於是開始了java多執行緒程式設計的學習，期間將

java多執行緒基礎總結【四】虛假喚醒

我們先來看一組例子package com.buerc.thread; public class TesProducerAndConsumer { public static void main(String[] args) { Clerk clerk=new Cler

最全java多執行緒學習總結1--執行緒基礎

  《java 核心技術》這本書真的不錯，知識點很全面，翻譯質量也還不錯，本系列博文是對該書中併發章節的一個總結。 什麼是執行緒   官方解釋：執行緒是作業系統能夠進行運算排程的最小單位，包含於程序之中，是程序中的實際運作單位。也就是說執行緒是程式碼執行的載體，我們所編寫的程式碼都是線上程上跑的，以一個最簡單

Java多執行緒學習與總結(Join)

join()方法的用法： join()是主執行緒 等待子執行緒的終止。也就是在子執行緒呼叫了 join() 方法後面的程式碼，只有等到子執行緒結束了才能執行。 例子如下： Java程式碼 p

Java多執行緒學習與總結(ThreadGroup)

在Java中每個執行緒都屬於某個執行緒組(ThreadGroup)。例如，如果在main()中產生一個執行緒，則這個執行緒屬於main執行緒組管理的一員，您可以使用下面的指令來獲得目前執行緒所屬的執行緒組名稱： Java程式碼

總結-Java多執行緒與高併發簡記

1、什麼是多執行緒？ 一個程序可以開啟多個執行緒，每個執行緒可以併發/並行執行不同任務。 2、Java多執行緒實現方式    2.1、繼承Thread類    2.2、實現Runnable介面方式實現多執行緒    2.3、使

java基礎總結(三十二)--java多執行緒程式設計例項

來自：https://blog.csdn.net/qq_34996727/article/details/80416277或者https://www.cnblogs.com/pureEve/p/6524366.html 一.相關知識：   Java多執行緒程式設計到的知識：