11月19日，業界應用最為廣泛的Kubernetes管理平台創建者Rancher Labs（以下簡稱Rancher）宣布Rio發布了beta版本，這是基於Kubernetes的應用程序部署引擎。它於今年5月份推出，現在最新的版本是v0.6.0。Rio結合了多種雲原生技術，從而簡化了將代碼從測試環境發布到生產環境的流程，同時保證了強大而安全的代碼體驗。

什麼是Rio？

下圖是Rio的架構：

Rio採用了諸如Kubernetes、knative、linkerd、cert-manager、buildkit以及gloo等技術，並將它們結合起來為用戶提供一個完整的應用程序部署環境。

Rio具有以下功能：

1. 從源代碼構建代碼，並將其部署到Kubernetes集群

2. 自動為應用程序創建DNS記錄，並使用Let’s Encrypt的TLS證書保護這些端點

3. 基於QPS以及工作負載的指標自動擴縮容

4. 支持金絲雀發布、藍綠髮布以及A/B部署

5. 支持通過服務網格路由流量

6. 支持縮容至零的serverless工作負載

7. Git觸發的部署

Rancher的產品生態

Rio屬於Rancher整套產品生態的一部分，這些產品支持從操作系統到應用程序的應用程序部署和容器運維。當Rio和諸如Rancher 2.3、k3s和RKE等產品結合使用時，企業可以獲得完整的部署和管理應用程序及容器的體驗。

深入了解Rio

要了解Rio如何實現上述功能，我們來深入了解一些概念以及工作原理。

安裝Rio

前期準備

• Kubernetes版本在1.15以上的Kubernetes集群

• 為集群配置的kubeconfig（即上下文是你希望將Rio安裝到的集群）

• 在$PATH中安裝的Rio CLI工具，可參閱以下鏈接，了解如何安裝CLI：
  https://github.com/rancher/rio/blob/master/README.md

安裝

使用安裝好的Rio CLI工具，調用rio install。你可能需要考慮以下情況：

ip-address：節點的IP地址的逗號分隔列表。你可以在以下情況使用：

• 你不使用（或不能使用）layer-4的負載均衡器

• 你的節點IP不是你希望流量到達的IP地址（例如，你使用有公共IP的EC2實例）

服 務

在Rio中，service是一個基本的執行單位。從Git倉庫或容器鏡像實例化之後，一個service由單個容器以及服務網格的關聯sidecar組成（默認啟用）。例如，運行使用Golang構建的一個簡單的“hello world”應用程序。

rio run https://github.com/ebauman/rio-demo

或者運行容器鏡像版本：

rio run ebauman/demo-rio:v1

還有其他選項也可以傳遞給rio run，如需要公開的任意端口（-p 80:8080/http），或者自動擴縮的配置（--scale 1-10）。你可以通過這一命令rio help run，查看所有可傳遞的選項。

想要查看你正在運行的服務，請執行rio ps：

$ rio ps
NAME            IMAGE                               ENDPOINT
demo-service    default-demo-service-4dqdw:61825    https://demo-service...

每次你運行一個新的服務，Rio將會為這一服務生成一個全局性的端點：

$ rio endpoints
NAME           ENDPOINTS
demo-service   https://demo-service-default.op0kj0.on-rio.io:30282

請注意，此端點不包括版本——它指向由一個common name標識的服務，並且流量根據服務的權重進行路由。

自動DNS&TLS

默認情況下，所有Rio集群都將為自己創建一個on-rio.io主機名，並以隨機字符串開頭（如lkjsdf.on-rio.io）。該域名成為通配符域名，它的記錄解析到集群的網關。如果使用NodePort服務，則該網關可以是layer-4負載均衡器，或者是節點本身。

除了創建這個通配符域名，Rio還會使用Let’s Encrypt為這個域名生成一個通配符證書。這會允許自動加密任何HTTP工作負載，而無需用戶進行配置。要啟動此功能，請傳遞-p參數，將http指定為協議，例如：

rio run -p 80:8080/http ...

自動擴縮容

Rio可以根據每秒所查詢到的指標自動擴縮服務。為了啟用這一特性，傳遞--scale 1-10作為參數到rio run，例如：

rio run -p 80:8080/http -n demo-service --scale 1-10 ebauman/rio-demo:v1

執行這個命令將會構建ebauman/rio-demo並且部署它。如果我們使用一個工具來添加負載到端點，我們就能夠觀察到自動擴縮容。為了證明這一點，我們需要使用HTTP端點（而不是HTTPS），因為我們使用的工具不支持TLS：

$ rio inspect demo-service
<snipped>
endpoints:
- https://demo-service-v0-default.op0kj0.on-rio.io:30282
- http://demo-service-v0-default.op0kj0.on-rio.io:31976
<snipped>

rio inspect除了端點之外還會显示其他信息，但我們目前所需要的是端點信息。使用HTTP端點以及HTTP基準測試工具rakyll / hey，我們可以添加綜合負載：

hey -n 10000 http://demo-service-v0-default.op0kj0.on-rio.io:31976

這將會發送10000個請求到HTTP端點，Rio將會提高QPS並適當擴大規模，執行另一個rio ps將會展示已經擴大的規模：

$ rio ps
NAME            ...     SCALE       WEIGHT
demo-service    ...     2/5 (40%)   100%

分階段發布、金絲雀部署以及權重

注意

對於每個服務，都會創建一個全局端點，該端點將根據基礎服務的權重路由流量。

Rio可以先交付新的服務版本，然後再推廣到生產環境。分階段發布一個新的版本十分簡單：

rio stage --image ebauman/rio-demo:v2 demo-service v2

這一命令使用版本v2，分階段發布demo-service的新版本，並且使用容器鏡像ebauman/rio-demo:v2。我們通過執行rio ps這一命令，可以看到新階段的發布：

$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  0%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  100%

請注意，新服務的端點具有v2的新增功能，因此即使權重設置為0%，訪問此端點仍將帶你進入服務的v2。這可以讓你能夠在向其發送流量之前驗證服務的運行情況。

說到發送流量：

$ rio weight demo-service@v2=5%
$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  5%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  95%

使用rio weight命令，我們現在將發送我們5%的流量（從全局的服務端點）到新版本。當我們覺得demo-service的v2性能感到滿意之後，我們可以將其提升到100%：

$ rio promote --duration 60s demo-service@v2
demo-service@v2 promoted

超過60秒之後，我們的demo-service@v2服務將會逐漸提升到接收100%的流量。在這一過程中任意端點上，我們可以執行rio ps，並且查看進程：

$ rio ps
NAME                IMAGE                   ENDPOINT                    WEIGHT
demo-service@v2     ebauman/rio-demo:v2     https://demo-service-v2...  34%
demo-service        ebauman/rio-demo:v1     https://demo-service-v0...  66%

路由（Routing）

Rio可以根據主機名、路徑、方法、標頭和cookie的任意組合將流量路由到端點。Rio還支持鏡像流量、注入故障，配置retry邏輯和超時。

創建一個路由器

為了開始制定路由決策，我們必須首先創建一個路由器。路由器代表一個主機名和一組規則，這些規則確定發送到主機名的流量如何在Rio集群內進行路由。你想要要定義路由器，需要執行rio router add。例如，要創建一個在默認測試時接收流量並將其發送到demo-service的路由器，請使用以下命令：

rio route add testing to demo-service

這將創建以下路由器：

$ rio routers
NAME             URL                            OPTS    ACTION      TARGET
router/testing   https://testing-default.0pjk...        to          demo-service,port=80

發送到https://testing-default…的流量將通過端口80轉發到demo-service。

請注意，此處創建的路由為testing-default. 。Rio將始終使用命名空間資源，因此在這種情況下，主機名測試已在默認命名空間中進行了命名。要在其他命名空間中創建路由器，請將 -n <namespace>傳遞給rio命令：

rio -n <namespace> route add ...

基於路徑的路由

為了定義一個基於路徑的路由，當調用rio route add時，指定一個主機名加上一個路徑。這可以是新路由器，也可以是現有路由器。

$ rio route add testing/old to demo-service@v1

以上命令可以創建一個基於路徑的路由，它會在https://testing-default. /old接收流量，並且轉發流量到 demo-service@v1服務。

標頭和基於方法的路由

Rio支持基於HTTP標頭和HTTP verbs的值做出的路由策略。如果你想要創建基於特定標頭路由的規則，請在rio route add命令中指定標頭：

$ rio route add --header X-Header=SomeValue testing to demo-service

以上命令將創建一個路由規則，它可以使用一個X-Header的HTTP標頭和SomeValue的值將流量轉發到demo-service。類似地，你可以為HTTP方法定義規則：

$ rio route add --method POST testing to demo-service

故障注入

Rio路由有一項有趣的功能是能夠將故障注入響應中。通過定義故障路由規則，你可以設置具有指定延遲和HTTP代碼的失敗流量百分比：

$ rio route add --fault-httpcode 502 --fault-delay-milli-seconds 1000 --fault-percentage 75 testing to demo-service

其他路由選項

Rio支持按照權重分配流量、為失敗的請求重試邏輯、重定向到其他服務、定義超時以及添加重寫規則。要查看這些選項，請參閱以下鏈接：

https://github.com/rancher/rio

自動構建

將git倉庫傳遞給rio run將指示Rio在提交到受監控的branch（默認值：master）之後構建代碼。對於Github倉庫，你可以通過Github webhooks啟動此功能。對於任何其他git repo，或者你不想使用webhooks，Rio都會提供一項“gitwatcher”服務，該服務會定期檢查您的倉庫中是否有更改。

Rio還可以根據受監控的branch的拉取請求構建代碼。如果你想要進行配置，請將--build-pr傳遞到rio run。還有其他配置這一功能的選項，包括傳遞Dockerfile的名稱、自定義構建的鏡像名稱以及將鏡像推送到指定的鏡像倉庫。

堆棧和Riofile

Rio使用稱為Riofile的docker-compose-style manifest定義資源

configs:
  conf:
    index.html: |-
      <!DOCTYPE html>
      <html>
      <body>

      <h1>Hello World</h1>

      </body>
      </html>
services:
  nginx:
    image: nginx
    ports:
    - 80/http
    configs:
    - conf/index.html:/usr/share/nginx/html/index.html

Riofile定義了一個簡單的nginx Hello World網頁所有必要的組件。通過rio up部署它，會創建一個Stack（堆棧），它是Riofile定義的資源的集合。

Riofile具有許多功能，例如觀察Git庫中的更改以及使用Golang模板進行模板化。

其他Rio組件

Rio還有許多功能，例如configs、secrets以及基於角色訪問控制（RBAC）。詳情可參閱：

https://rio.io/

Rio可視化

Rio Dashboard

Rio的beta版本包括了一個全新的儀錶盤，使得Rio組件可視化。要訪問此儀錶盤，請執行命令：rio dashboard。在有GUI和默認瀏覽器的操作系統上，Rio將自動打開瀏覽器並加載儀錶盤。

你可以使用儀錶盤來創建和編輯堆棧、服務、路由等。此外，可以直接查看和編輯用於各種組件技術（Linkerd、gloo等）的對象，儘管不建議這樣做。儀錶盤目前處於開發的早期階段，因此某些功能的可視化（如自動縮放和服務網格）尚不可用。

Linkerd

作為Rio的默認服務網格，Linked附帶了一個儀錶盤作為產品的一部分。該儀錶盤可以通過執行rio linkerd來使用，它將代理本地本地主機流量到linkerd儀錶盤（不會在外部公開）。與Rio儀錶盤類似，有GUI和默認瀏覽器的操作系統上，Rio將自動打開瀏覽器並加載儀錶盤：

Linkerd儀錶盤显示了Rio集群的網格配置、流量和網格組件。Linkerd提供了Rio路由的某些功能組件，因此這些配置可能會显示在此儀錶盤上。還有一些工具可用於測試和調試網格配置和流量。

結 論

Rio為用戶提供許多功能，是一款強大的應用程序部署引擎。這些組件可以在部署應用程序時為開發人員提供強大的功能，使流程穩定而安全，同時輕鬆又有趣。在Rancher產品生態中，Rio提供了企業部署和管理應用程序和容器的強大功能。

如果你想了解Rio的更多信息，歡迎訪問Rio主頁或Github主頁：

https://rio.io

https://github.com/rancher/rio

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

0.前言

m3u8是一種很常見的網頁視頻播放器的視頻源，比如說中國大學MOOC中課程就是使用了該種視頻格式。

隨便打開一門課程，就可以發現在網絡請求中存在一個m3u8的文件，在preview中預覽，它並不像我們想象中是亂碼的視頻流。

裏面是一個列表，有一堆ts結尾的文件名，每個下面還跟了一個EXTINF的字段，好像是時間，在我們播放視頻時，網絡請求中會不斷出現請求ts的內容。

隨便打開一個ts文件，它的內容卻是如圖視頻流一般亂碼的。

說到這裏，你可能有猜測了，m3u8並不是視頻流的文件，而有可能是組織ts文件的規範，EXTINF代表播放每多少秒去請求下一片ts流。

這種邊看邊加載的方法無疑可以減少我們的網絡負荷。

要用爬蟲爬取這類視頻的方法也很簡單，我們只需要獲得m3u8文件，就可以得到視頻的ts地址了，將所有ts請求下來之後進行合併，就可以得到視頻文件了。

不過要提的一點是，很多視頻網站會對他們的ts進行加密，我們下載下來合併之後可能視頻能看，但是播放器放着放着就卡住了，然後之後黑屏畫面。

1.編碼部分

我們先根據m3u8來判斷一下創建咋樣一個代表M3U8視頻對象的類。

我們首先需要定義一個list，來存放這個m3u8視頻下所有的ts文件，也就是後面說到的TS類。

這裏提一點，m3u8裏面的ts的路徑一般對路徑，會和m3u8在同一文件夾，我們代碼中也是這麼認為了，但是難免有些網站會單獨存放m3u8和ts文件，如果遇到這種情況，修改一下代碼即可。

有了ts的名稱，我們還需要URL的前綴，也就是圖中紫色劃線部分，也就是basepath。

此外，我們還需要一個TS對象。

這個對象中存儲TS文件名稱以及時間EXTINF。

定義完實體類，就需要編寫下載視頻的過程了。

首先需要請求到m3u8的文件，此處使用Java的HttpURLConnection來請求獲取，其它語言類似，只需要請求到文件即可。

請求到了m3u8的文本內容，我們還需要解析它 ，從中得到ts的名稱。

得到了M3U8視頻對象之後，我們就可以遍歷請求它的list中TS對象的名稱屬性來下載ts文件了。

這麼多ts文件如果我們在單線程中遍歷請求，會很耗費時間，Java給我們提供了Stream，其中parallel可以讓我們併發去遍歷集合，效率會提升不少。

依舊是使用HttpURLConnection來做請求，不過最好本次設置超時時間。

這樣就可以請求到所有ts文件了。

最後要做的就是合併這些ts文件成為一個MP4文件。

對於未加密的正常ts文件，我們只需要按照編號順序直接拼接即可。

這樣就算是完成了M3U8視頻抓取了。

2.打包使用

下載地址：

在命令行中java -jar m3u8-down.jar [m3u8地址]，會显示報錯信息。

也可以直接m3u8-down.jar [m3u8地址]，不會显示保存信息，會在後台執行。

最終會在同目錄下生成一個output.mp4的文件，temp文件可以刪除。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

Java多線程系列文章是Java多線程的詳解介紹，對多線程還不熟悉的同學可以先去看一下我的這篇博客，這篇博客從宏觀層面介紹了多線程的整體概況，接下來的幾篇文章是對多線程的深入剖析。

 

多線程的常用方法

1、currentThread()方法：

介紹：currentThread()方法可返回該代碼正在被哪個線程調用的信息。

示例：

例1：

public class Test01 {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName());
	}
	
}

結果：
main

　　

結果說明，main方法被名為main的線程調用

 

例2：

class Mythread extends Thread{
	
	public Mythread() {
		System.out.println("構造方法的打印："+Thread.currentThread().getName());
	}
	
	@Override
	public void run() {
		System.out.println("run方法的打印："+Thread.currentThread().getName());
	}
}

public class Test01 {

	public static void main(String[] args) {
		Mythread t=new Mythread();
		t.start();//①
	}
	
}

結果：
構造方法的打印：main
run方法的打印：Thread-0

　　

從結果可知：Mythread的構造方法是被main線程調用的，而run方法是被名稱為Thread-0的線程調用的，run方法是線程自動調用的

現在我們將①處的代碼改為t.run()，現在的輸出結果如下：

構造方法的打印：main
run方法的打印：main

　　

從結果中我們可以看到兩次的結果显示都是main線程調用了方法，因為當你使用t.start()方法的時候是線程自動調用的run()方法，所以輸出的是Thread-0，當你直接調用run()方法時，和調用普通方法沒有什麼區別，所以是main線程調用run()

 

2、isAlive()方法：

介紹：isAlive()方法的功能是判斷當前的線程是否處於活動狀態

示例：

例1：

class Mythread extends Thread{
	
	@Override
	public void run() {
		System.out.println("run =="+this.isAlive());
	}
	
}

public class Test01 {

	public static void main(String[] args) {
		Mythread thread=new Mythread();
		System.out.println("begin =="+thread.isAlive());//①
		thread.start();//②
		System.out.println("end =="+thread.isAlive());//③
	}
	
}

結果：
begin ==false
end ==true
run ==true

　　

方法isAlive()的作用是測試線程是否處於活動狀態。那麼什麼情況下是活動狀態呢？活動狀態就是線程已經啟動且尚未停止。線程處於正在運行或準備開始運行的狀態，就認為線程是存活的

①處代碼的結果為false，因為此時線程還未啟動；

②處代碼調用了run()方法輸出結果為run ==true，此時線程處於活動狀態；

③處代碼的結果為true，有的同學看到這個輸出可能會不理解，不是說線程處於活動狀態isAlive()方法的結果才是true，現在程序都已經運行結束了為什麼還是true？這裏的輸出結果是不確定的，我們再來看下面一段代碼

我們將例1中的代碼稍做修改，代碼如下：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		System.out.println("begin =="+thread.isAlive());//①
		thread.start();//②
		Thread.sleep(1000);//這裏加了一行代碼，讓當前線程沉睡1秒
		System.out.println("end =="+thread.isAlive());//③
	}
	
}

結果：
begin ==false
run ==true
end ==false

　　

現在我們看到③處的代碼結果為end ==false，因為thread對象已經在1秒內執行完畢，而上面代碼輸出結果為true是因為thread線程未執行完畢。

 

3、sleep()方法：

介紹：

方法sleep()的作用是在指定的毫秒數內讓當前“正在執行的線程”休眠（暫停執行），這個“正在執行的線程”是指this.currentThread()返回的線程。

示例：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		try {
			System.out.println("run threadName="+this.currentThread().getName()+" begin");
			Thread.sleep(2000);
			System.out.println("run threadName="+this.currentThread().getName()+" end");
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		System.out.println("begin ="+System.currentTimeMillis());
		thread.run();//①
		System.out.println("end ="+System.currentTimeMillis());
	}
	
}

結果：
begin =1574660731663
run threadName=main begin
run threadName=main end
end =1574660733665

　　

從結果中可以看出main線程暫停了2秒（因為這裏調用的是thread.run()）

下面我們將①處的代碼改成thread.start()，再來看下運行結果：

begin =1574661491412
end =1574661491412
run threadName=Thread-0 begin
run threadName=Thread-0 end

　　

由於main線程與thread線程是異步執行的，所以首先打印的信息為begin和end，而thread線程是隨後運行的，在最後兩行打印run begin和run end的信息。

 

4、getId()方法：

介紹：getId()方法的作用是取得線程的唯一標識

示例：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Thread thread=Thread.currentThread();
		System.out.println(thread.getName()+" "+thread.getId());
	}
	
}

結果：main 1

　　

從運行結果可以看出，當前執行代碼的線程名稱是main，線程id值為1

 

5、停止線程：

介紹：停止線程是在多線程開發時很重要的技術點，掌握此技術可以對線程的停止進行有效的處理。停止線程在Java語言中並不像break語句那樣乾脆，需要一些技巧性的處理。

在java中有三種方法可以停止線程

1. 使用退出標誌，讓線程正常退出，也就是當run方法執行完之後終止
2. 使用stop方法強制終止線程，但是不推薦使用，因為stop和suspend及resume一樣，是java廢棄的方法
3. 使用interrupt方法中斷線程（推薦使用）

示例：

例1：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		for(int i=0;i<5000;i++) {
			System.out.println("i="+(i+1));
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(2000);
		thread.interrupt();
	}
	
}

　　

運行結果：

 

從運行結果我們可以看出最後i=500000，調用interrupt方法沒有停止線程，那麼該如何停止線程呢？

在介紹如何停止線程時，我們先來介紹一下如何判斷線程是否處於停止狀態

Thread類中提供了兩種方法用來判斷線程是否停止：

1、this.interrupted()：測試當前線程是否已經中斷，執行后具有將狀態標誌清除為false的功能

public static boolean interrupted() {
        return currentThread().isInterrupted(true);
}

　　

2、this.isInterrupted()：測試線程Thread對象是否已經中斷，但是不清除狀態標誌

public boolean isInterrupted() {
        return isInterrupted(false);
}

　　

讀者可以仔細觀看一下這兩個方法的聲明有什麼不同？

 

例2：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		for(int i=0;i<5000;i++) {
			System.out.println("i="+(i+1));
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(1000);
		thread.interrupt();
		System.out.println("是否停止1？="+thread.interrupted());
		System.out.println("是否停止2？="+thread.interrupted());
		System.out.println("end!");
	}
	
}

　　

結果：

 

 

 輸出結果显示調用了thread.interrupt()方法后線程並未停止，這也就證明了interrupted()方法的解釋：測試當前線程是否已經中斷。這個當前線程是main，它從未斷過，所以打印的結果是兩個false。

如果想讓main線程結束該怎麼做？

將main方法改成如下：

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Thread.currentThread().interrupt();
		System.out.println("是否停止1？="+Thread.interrupted());
		System.out.println("是否停止2？="+Thread.interrupted());
		System.out.println("end!");
	}
	
}

結果：
是否停止1？=true
是否停止2？=false
end!

　　

從輸出結果我們可以看出，方法interrupted()的確判斷出當前線程是否是停止狀態。但為什麼第2個值是false？

查看一下官方文檔的介紹：

測試當前線程是否已經中斷。線程的中斷狀態由該方法清除。換句話說，如果連續兩次調用該方法，則第二次調用將返回false（在第一次調用已清除了其中斷狀態之後，且第二次調用檢驗完中斷狀態前，當前線程再次中斷的情況除外）。

 文檔中說明的非常清楚，interrupted()方法具有清除狀態的功能，所以第二次調用interrupted方法返回的值時false。

下面我們來看一下isInterrupted()方法，將main方法改成如下代碼：

public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
		thread.interrupt();
		Thread.sleep(1000);
		System.out.println("是否停止1？="+thread.isInterrupted());
		System.out.println("是否停止2？="+thread.isInterrupted());
		System.out.println("end");
}
結果：

是否停止1？=true
是否停止2？=true
end

　　

從結果可以看出，方法isInterrrupted()並未清除狀態，所以結果為兩個true。

 

例3：在沉睡中停止

當線程調用sleep()方法后再調用interrupt()方法後會有什麼結果：

class Mythread extends Thread{
	
	@Override
	public void run() {
		
		try {
			System.out.println("run begin");
			Thread.sleep(200000);
			System.out.println("run end");
		} catch (InterruptedException e) {
			System.out.println("在沉睡中被停止，進入catch!"+this.isInterrupted());
			e.printStackTrace();
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		try {
			Mythread thread=new Mythread();
			thread.start();
			Thread.sleep(200);
			thread.interrupt();
		}catch(Exception e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
		System.out.println("end!");
	}
	
}

　　

 

 

6、暫停線程：

暫停線程意味着此線程還可以恢復運行。在java多線程中，可以使用suspend()方法暫停線程，使用resume()方法恢複線程的執行

例1：

class Mythread extends Thread{
	
	private long i=0;
	public long getI() {
		return i;
	}
	
    public void setI(long i) {
		this.i = i;
	}
	
	@Override
	public void run() {
		while(true) {
			i++;
		}
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		Mythread thread=new Mythread();
		thread.start();
		Thread.sleep(5000);
		//A段
		thread.suspend();
		System.out.println("A= "+System.currentTimeMillis()+" i="+thread.getI());
		Thread.sleep(5000);
		System.out.println("A= "+System.currentTimeMillis()+" i="+thread.getI());
		
		//B段
		thread.resume();
		Thread.sleep(5000);
		
		//C段
		thread.suspend();
		System.out.println("B= "+System.currentTimeMillis()+" i="+thread.getI());
		Thread.sleep(5000);
		System.out.println("B= "+System.currentTimeMillis()+" i="+thread.getI());
		
	}
	
}

　　

結果：

 

從控制台打印的時間上來看，線程的確被暫停了，而且還可以恢復成運行狀態。

 

7、yield方法：

介紹：yield()方法的作用是放棄當前的CPU資源，將它讓給其他的任務去佔用CPU執行時間。但放棄的時間不確定，有可能剛剛放棄，馬上又獲得CPU時間片

示例：

class Mythread extends Thread{
	
	@Override
	public void run() {
		long beginTime=System.currentTimeMillis();
		int count=0;
		for(int i=0;i<500000;i++) {
　　　　　　　　　　　　　　 //Thread.yield();①
			count=count+(i+1);
		}
		long endTime=System.currentTimeMillis();
		System.out.println("用時："+(endTime-beginTime)+"毫秒！");
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		Mythread thread=new Mythread();
		thread.start();
	}
	
}

結果：用時：2毫秒！

　　

現在將①處的代碼取消註釋，我們再來看一下運行結果：

用時：213毫秒！

　　

將CPU讓給其他資源導致速度變慢

 

8、線程優先級：

介紹：

在操作系統中，線程可以劃分優先級，優先級較高的線程得到的CPU資源較多，也就是CPU優先執行優先級較高的線程對象中的任務。

設置線程優先級有助於幫“線程規劃器”確定在下一次選擇哪一個線程來優先執行。

設置線程的優先級使用setPriority()方法，此方法在JDK的源代碼如下：

public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
}

　　

在Java中，線程的優先級為1-10這10個等級，如果小於1或大於10，則JDK拋出異常throw new IllegalArgumentException()。

通常高優先級的線程總是先執行完，但是並不是一定的，高優先級和低優先級的線程會交替進行，高優先級執行的次數多一些

 

線程優先級的繼承特性：

在Java中，線程的優先級具有繼承性，比如A線程啟動B線程，則B線程的優先級與A是一樣的。

class Mythread2 extends Thread{
	@Override
	public void run() {
		System.out.println("Mythread2 run priority="+this.getPriority());
	}
}


class Mythread1 extends Thread{
	
	@Override
	public void run() {
		System.out.println("Mythread run priority="+this.getPriority());
		Mythread2 thread2=new Mythread2();
		thread2.start();
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
    	        //Thread.currentThread().setPriority(6);①
		System.out.println("main thread end priority="+Thread.currentThread().getPriority());
		Mythread1 thread1=new Mythread1();
		thread1.start();
	}
	
}

結果:
main thread begin priority=5
main thread end priority=5
Mythread run priority=5
Mythread2 run priority=5

　　

可以看到上面幾個線程的優先級都為5

現在將①處的代碼註釋掉后的結果是：

main thread begin priority=5
main thread end priority=6
Mythread run priority=6
Mythread2 run priority=6

　　

優先級被更改后再繼續繼承

 

9、守護線程：

在java中有兩種線程，一種是用戶線程，另一種是守護線程。

守護線程是一種特殊的線程，它的特性有“陪伴”的含義，當進程中不存在非守護線程了，則守護線程自動銷毀。典型的守護線程就是垃圾回收線程，當進程中沒有非守護線程了，則垃圾回收線程也就沒有存在的必要了，自動銷毀。用個比較通俗的比喻來解釋一下：“守護線程”：任何一個守護線程都是整個JVM中所有非守護線程的“保姆”，只要當前JVM實例中存在任何一個非守護線程沒有結束，守護線程就在工作，只有當最後一個非守護線程結束時，守護線程才隨着JVM一同結束工作。Daemon的作用是為其他線程的運行提供便利服務，守護線程最典型的應用就是GC（垃圾回收器），它就是一個很稱職的守護者。

 

class Mythread extends Thread{
	
	private int i=0;
	
	
	@Override
	public void run() {
		
		try {
			while(true) {
				i++;
				System.out.println("i="+(i));
				Thread.sleep(1000);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
}

public class Test01 {

	public static void main(String[] args) throws InterruptedException {
		
		try {
			Mythread thread=new Mythread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我離開Thread對象就不再打印了，也就是停止了");
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
}

　　

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

本文整理了我自己在Java開發中常用的jar包以及常用的API記錄。

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

common-lang3

簡介

一個現在最為常用的jar包，封裝了許多常用的工具包

依賴：

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.4</version>
</dependency>

主要常見的類如下：

• 數組工具類 ArrayUtils
• 日期工具類 DateUtils DateFormatUtils
• 字符串工具類 StringUtils
• 数字工具類 NumberUtils
• 布爾工具類 BooleanUtils
• 反射相關工具類 FieldUtils、MethodUtils、MemberUtils、TypeUtils、ConstructorUtils
• 對象工具類 ObjectUtils
• 序列化工具類 SerializationUtils

API介紹

這裏我只介紹經常使用的幾個工具類及方法，ArrayUtils，StringUtils，NumberUtils，DateUtils，其他的請查看官方API文檔吧

1.ArrayUtils

方法名	說明
add
remove
clone	複製數組
addAll
removeAll	第二個參數傳入需要刪除的下標（可以指定多個下標）
toObject	把數值（int[],double[]）轉為包裝類(Int[],Double[])
indexOf	在數組按順序查找，找到第一個滿足對應的數值的下標
lastIndexOf	在數組按順序查找，找到最後一個滿足對應的數值的下標
contains	數組是否包含某個值
isEmpty	判斷數組是否為空
isNotEmpty	判斷數組是否不為空
reverse	數組反轉
subarray	指定區間截取數組，區間為半開區間，不包含末尾
toArray	接收一個多個對象，把這幾個對象轉為對應類型的數組
toMap	將一個二維數組轉為Map

2.NumberUtils

方法名	說明
min	比較三個數，返回最小值 或比較指定的幾個數，返回最小值
max	比較三個數，返回最大值 或比較指定的幾個數，返回最大值
createInt	從傳入的String中創建對應類型的數值，createDouble,createFloat…
toInt	將指定字符串轉為Int類型，可以選擇指定默認數值，如果字符串為null則返回默認數值，除此之外，還有toDouble,toLong…等轉為不同類型的方法
compare	比較兩個同類型數值的大小
isDigits	判斷字符串是否只包含数字
isParsable	判斷字符串是否可轉換為Long,Int等類型
isNumber	判斷字符串是否為數值（0x,0X開頭等進制數值）

3.DateUtils

方法名	說明
parseDate	將Date對象轉為字符串
isSameDay	判斷兩個Dated對象是否為同一天
isSameDay	判斷兩個Dated對象是否為同一天
addHour	將指定的Date對象加上指定小時，除此之外，還有addMonth,addDay..等

DateFormatUtils正如其名，是用來把時間轉為字符串，這裏就不再多說

4.StringUtils

方法名	說明
join	將指定的數組連接成字符串，並添加指定的分割字符
containOnly	字符串是否只包含某個字符串
substringBefore	截取指定字符串前面的內容
substringAfter	截取指定字符串後面的內容（不包括指定字符串）
substringBetween	截取字符串某區間內容，如substringBetween(“abcde”,”a”,”e”)=”bcd”
difference	比較兩個字符串，返回兩個字符串不同的內容，具體可以看API文檔給出的示例
isBlank	判斷字符串是否為空白，null,””,” “這三個結果都是為true
isEmpty	判斷字符串是否為空(只要不為null，或傳入的String對象的長度不為0即為true)
countMatches	判斷指定的字符串在某個字符串中出現的次數
deleteWhitespace	刪除字符串中的空格
defaultIfBlank	如果字符串為空白，則返回一個指定的默認值(null或某個String)
defaultIfEmpty	如果字符串為空，則返回一個指定的默認值(null或某個String)
capitalize	將指定字符串首字母大寫
abbreviate	將指定字符串的後面三位轉為…
swapCase	將字符串中的字母大小寫反轉,如aBc變為AbC
lowerCase	將字符串的字母全部轉為小寫
upperCase	將字符串的字母全部轉為大寫
left	取字符串左邊幾個字符，如left(“hello”,3)=”hel”，right與此相反
leftPad	字符串的長度不夠，則使用指定字符填充指定字符串，如leftPad(“hel”,5,”z”)=”zzhel”,rightPad方法與此相反
prependIfMissing	指定字符串不以某段字符串開頭，則自動添加開頭，如prependIfMissing(“hello”,”li”)=”lihello”
prependIfMissing	指定字符串不以某段字符串開頭(忽略大小寫)，則自動添加開頭
getCommonPrefix	獲得多個字符串相同的開頭內容，接收參數為多個字符串
removeEnd	刪除字符串中結尾（滿足是以某段內容結尾），如removeEnd(“hello”,”llo”)=”he”
removeEndIgnoreCase	與上面一樣，忽略大小寫
removeStart	與上面的相反
remove	刪除字符串中的指定內容，如remove(“hello”,”l”)=”heo”
removeIgnoreCase	刪除字符串中的指定內容，如remove(“hello”,”l”)=”heo”
strip	清除字符串開頭和末尾指定的字符(第二個參數為null,用來清除字符串開頭和末尾的空格)，如strip(” abcxy”,”xy”)=” abc”,strip(” abcxy”,”yx”)=” abc”
stripStart	清除字符串開頭指定字符
stripEnd	清除字符串末尾指定的字符

common-io

簡介

常用的IO流工具包

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

API

我們主要關心的就是Utils後綴的那幾個類即可，可以看到，common-io庫提供了FileUtils,FileSystemUtils,FileNameUtils,FileFilterUtils,IOUtils

FileUtils

• 寫出文件
• 讀取文件
• 創建一個有父級文件夾的文件夾
• 複製文件和文件夾
• 刪除文件和文件夾
• URL轉文件
• 通過過濾器和擴展名來篩選文件和文件夾
• 比較文件內容
• 文件最後修改時間
• 文件校驗

FileSystemUtils

關於文件系統的相關操作，如查看C盤的大小，剩餘大小等操作

IOUtils

字面意思，是封裝了IO流的各種操作的工具類

Log4j

簡介

Log4J 是 Apache 的一個開源項目，通過在項目中使用 Log4J，我們可以控制日誌信息輸出到控制台、文件、GUI 組件、甚至是數據庫中。

我們可以控制每一條日誌的輸出格式，通過定義日誌的輸出級別，可以更靈活的控制日誌的輸出過程，方便項目的調試。

依賴：

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

結構

Log4J 主要由 Loggers (日誌記錄器)、Appenders（輸出端）和 Layout（日誌格式化器）組成。

其中Loggers 控制日誌的輸出級別與日誌是否輸出；
Appenders 指定日誌的輸出方式（輸出到控制台、文件等）；
Layout 控制日誌信息的輸出格式。

日誌級別：

級別	說明
OFF	最高日誌級別，關閉左右日誌
FATAL	將會導致應用程序退出的錯誤
ERROR	發生錯誤事件，但仍不影響系統的繼續運行
WARN	警告，即潛在的錯誤情形
INFO	一般和在粗粒度級別上，強調應用程序的運行全程
DEBUG	一般用於細粒度級別上，對調試應用程序非常有幫助
ALL	最低等級，打開所有日誌記錄

我們主要使用這四個：Error>Warn>Info>Debug

使用

我們可以使用兩種方式來運行Log4j，一種是java代碼方式，另外一種則是配置文件方式

例子（Java方式）

public class Log4JTest {
    public static void main(String[] args) {   
        //獲取Logger對象的實例（傳入當前類）         
        Logger logger = Logger.getLogger(Log4JTest.class);
        //使用默認的配置信息，不需要寫log4j.properties
        BasicConfigurator.configure();
        //設置日誌輸出級別為WARN，這將覆蓋配置文件中設置的級別，只有日誌級別低於WARN的日誌才輸出
        logger.setLevel(Level.WARN);
        logger.debug("這是debug");
        logger.info("這是info");
        logger.warn("這是warn");
        logger.error("這是error");
        logger.fatal("這是fatal");
    }
}

例子（配置文件方式）

上面的例子，我們想要實現打印Log，但是每次都要寫一遍，浪費時間和精力，所以，Log4j提供了另外一種方式來配置好我們的信息

創建一個名為log4j.properties的文件，此文件需要放在項目的根目錄（約定），如果是maven項目，直接放在resources文件夾中即可

log4j.properties

#控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

#log jdbc
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=WARN
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

#log mybatis設置
#log4j.logger.org.apache.ibatis=DEBUG
log4j.logger.org.apache.ibatis.jdbc=error
log4j.logger.org.apache.ibatis.io=info
log4j.logger.org.apache.ibatis.datasource=info

#springMVC日誌
log4j.logger.org.springframework.web=WARN

# 文件輸出配置
log4j.appender.A = org.apache.log4j.DailyRollingFileAppender
log4j.appender.A.File = D:/log.txt #指定日誌的輸出路徑
log4j.appender.A.Append = true
log4j.appender.A.Threshold = DEBUG
log4j.appender.A.layout = org.apache.log4j.PatternLayout #使用自定義日誌格式化器
log4j.appender.A.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n #指定日誌的輸出格式
log4j.appender.A.encoding=UTF-8 #指定日誌的文件編碼

#指定日誌的輸出級別與輸出端
log4j.rootLogger=DEBUG,Console,A

#指定某個包名日誌級別（不能超過上面定義的級別，否則日誌不會輸出）
log4j.logger.com.wan=DEBUG

之後使用的話就比較簡單了

//Logger的初始化（這個推薦定義為全局變量，方便使用）
Logger logger = Logger.getLogger(Log4JTest.class);
//輸出Log
logger.info("這是info");

參考鏈接：

lombok

簡介

平常我們創建實體類的時候，需要get/set方法，極其麻煩，雖然IDEA等IDE都是有提供了快捷生成，不過，最好的解決方法還是省略不寫

而lombok就是這樣的一個框架，實現省略get/set方法，當然，lombok的功能不只有此，還有equal，toString方法也可以由此框架自動生成

lombok的原理是使用註解，之後就會在編譯過程中，給Class文件自動加上get/set等方法

不過IDEA似乎無法識別，代碼檢查還是會報錯，所以，使用IDEA的時候還得安裝一個插件，在plugin搜索lombok，之後安裝重啟即可，如圖

之後為Java項目添加依賴

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
    <scope>provided</scope>
</dependency>

使用示例

1.實體類省略get/set
估計Kotlin中的data關鍵字就是參照着lombok實現的

//這裏我們只需要為類添加Data註解，就會自動生成對應屬性的get/set方法，toString，equal等方法
@Data
public class User {
    private String username;
    private String password;
}

2.需要無參構造以及get/set方法

@Getter
@Setter
@NoArgsConstructor
public class User {
    private String username;
    private String password;
}

3.鏈式調用set方法

@Data
@Accessors(chain = true)
public class User {
    private String username;
    private String password;
}

//使用
User user = new User();
user.setUsername("helo").setPassword("123");

4.參數不為空

//如果調用此方法，就會抱一個空指針錯誤
public String print(@NotNull String str){
    ...
}

5.只需要toString

@ToString(callSuper=true, includeFieldNames=true)
public class User {
    private String username;
    private String password;
    //省略的get/set方法
}

6.builder模式創建實體類對象

@Data
@Builder
public class User {
    private String username;
    private String password;
}
//使用
User user1 = User.builder().username("user1").password("123").build();

7.工具類

@UtilityClass
public class MyUtils{
    //會將此方法自動轉為靜態方法
    public void print(String str){
        ...
    }
}
//使用
MyUtils.print("hello");

8.自動關閉流

public static void main(String[] args) throws Exception {
    //使用Cleanup會自動調用close方法
    @Cleanup InputStream in = new FileInputStream(args[0]);
    @Cleanup OutputStream out = new FileOutputStream(args[1]);
    byte[] b = new byte[1024];
    while (true) {
        int r = in.read(b);
        if (r == -1) break;
        out.write(b, 0, r);
    }
}

9.省略Logger時的初始化

@Log4j
@Log
public class User{
    //會自動添加此語句
    //Logger logger = Logger.getLogger(User.class);
    ...
}

參考：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

　　在上一篇博文發了一天左右的時間，就收到了博客園許多讀者的評論和推薦，非常感謝，我也會及時回復讀者的評論。之後我也將繼續撰寫博文，梳理相關.NET的知識，希望.NET的圈子能越來越大，開發者能了解/深入.NET的本質，將工作做的簡單又高效，拒絕重複勞動，拒絕CRUD。

　　ok,咱們開始繼續Emit的探索。在這之前，我先放一下我往期關於Emit的文章，方便讀者閱讀。

　　《》

一、基礎知識

　　既然C#作為一門面向對象的語言，所以首當其沖的我們需要讓Emit為我們動態構建類。

　　廢話不多說，首先，我們先來回顧一下C#類的內部由什麼東西組成：

　　(1) 字段-C#類中保存數據的地方，由訪問修飾符、類型和名稱組成；

　　(2) 屬性-C#類中特有的東西，由訪問修飾符、類型、名稱和get/set訪問器組成，屬性的是用來控制類中字段數據的訪問，以實現類的封裝性；在Java當中寫作getXXX()和setXXX(val),C#當中將其變成了屬性這種語法糖；

　　(3) 方法-C#類中對邏輯進行操作的基本單元,由訪問修飾符、方法名、泛型參數、入參、出參構成；

　　(4) 構造器-C#類中一種特殊的方法，該方法是專門用來創建對象的方法，由訪問修飾符、與類名相同的方法名、入參構成。

　　接着，我們再觀察C#類本身又具備哪些東西：

　　(1) 訪問修飾符-實現對C#類的訪問控制

　　(2) 繼承-C#類可以繼承一個父類，並需要實現父類當中所有抽象的方法以及選擇實現父類的虛方法，還有就是子類需要調用父類的構造器以實現對象的創建

　　(3) 實現-C#類可以實現多個接口，並實現接口中的所有方法

　　(4) 泛型-C#類可以包含泛型參數，此外，類還可以對泛型實現約束

　　以上就是C#類所具備的一些元素，以下為樣例：

public abstract class Bar
{
    public abstract void PrintName();
}

public interface IFoo<T>
{
    public T Name { get; set; }
}
//繼承Bar基類，實現IFoo接口,泛型參數T
public class Foo<T> : Bar, IFoo<T>
　　//泛型約束
　　where T : struct
{
    //構造器
    public Foo(T name):base()
    {
        _name = name;
    }

    //字段
    private T _name;
    //屬性
    public T Name { get => _name; set => _name = value; }
    //方法
    public override void PrintName()
    {
　　　　Console.WriteLine(_name.ToString());
    }
}

　　在探索完了C#類及其定義后，我們要來了解C#的項目結構組成。我們知道C#的一個csproj項目最終會對應生成一個dll文件或者exe文件，這一個文件我們稱之為程序集Assembly；而在一個程序集中，我們內部包含和定義了許多命名空間，這些命令空間在C#當中被稱為模塊Module，而模塊正是由一個一個的C#類Type組成。

 

 

 

 　　所以，當我們需要定義C#類時，就必須首先定義Assembly以及Module，如此才能進行下一步工作。

二、IL概覽

 　　由於Emit實質是通過IL來生成C#代碼，故我們可以反向生成，先將寫好的目標代碼寫成cs文件，通過編譯器生成dll，再通過ildasm查看IL代碼，即可依葫蘆畫瓢的編寫出Emit代碼。所以我們來查看以下上節Foo所生成的IL代碼。

　　

 

 

 　　從上圖我們可以很清晰的看到.NET的層級結構，位於樹頂層淺藍色圓點表示一個程序集Assembly，第二層藍色表示模塊Module，在模塊下的均為我們所定義的類，類中包含類的泛型參數、繼承類信息、實現接口信息，類的內部包含構造器、方法、字段、屬性以及它的get/set方法，由此，我們可以開始編寫Emit代碼了

三、Emit編寫

　　有了以上的對C#類的解讀和IL的解讀，我們知道了C#類本身所需要哪些元素，我們就開始根據這些元素來開始編寫Emit代碼了。這裏的代碼量會比較大，請讀者慢慢閱讀，也可以參照以上我寫的類生成il代碼進行比對。

　　在Emit當中所有創建類型的幫助類均以Builder結尾，從下錶中我們可以看的非常清楚

元素中文	元素名稱	對應Emit構建器名稱
程序集	Assembly	AssemblyBuilder
模塊	Module	ModuleBuilder
類	Type	TypeBuilder
構造器	Constructor	ConstructorBuilder
屬性	Property	PropertyBuilder
字段	Field	FieldBuilder
方法	Method	MethodBuilder

　　由於創建類需要從Assembly開始創建，所以我們的入口是AssemblyBuilder

　　(1) 首先，我們先引入命名空間，我們以上節Foo類為樣例進行編寫

using System.Reflection.Emit;

　　(2) 獲取基類和接口的類型

var barType = typeof(Bar);
var interfaceType = typeof(IFoo<>);

　　(3) 定義Foo類型，我們可以看到在定義類之前我們需要創建Assembly和Module

//定義類
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Edwin.Blog.Emit"), AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule("Edwin.Blog.Emit");
var typeBuilder = moduleBuilder.DefineType("Foo", TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit);

　　(4) 定義泛型參數T,並添加約束

//定義泛型參數
var genericTypeBuilder = typeBuilder.DefineGenericParameters("T")[0];
//設置泛型約束
genericTypeBuilder.SetGenericParameterAttributes(GenericParameterAttributes.NotNullableValueTypeConstraint);

　　(5) 繼承和實現接口，注意當實現類的泛型參數需傳遞給接口時，需要將泛型接口添加泛型參數后再調用AddInterfaceImplementation方法

//繼承基類
typeBuilder.SetParent(barType);
//實現接口
typeBuilder.AddInterfaceImplementation(interfaceType.MakeGenericType(genericTypeBuilder));

　　(6) 定義字段，因為字段在構造器值需要使用，故先創建

//定義字段
var fieldBuilder = typeBuilder.DefineField("_name", genericTypeBuilder, FieldAttributes.Private);

　　(7) 定義構造器，並編寫內部邏輯

//定義構造器
var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[] { genericTypeBuilder });
var ctorIL = ctorBuilder.GetILGenerator();
//Ldarg_0在實例方法中表示this，在靜態方法中表示第一個參數
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
//為field賦值
ctorIL.Emit(OpCodes.Stfld, fieldBuilder);
ctorIL.Emit(OpCodes.Ret);

　　(8) 定義Name屬性

//定義屬性
var propertyBuilder = typeBuilder.DefineProperty("Name", PropertyAttributes.None, genericTypeBuilder, Type.EmptyTypes);

　　(9) 編寫Name屬性的get/set訪問器

//定義get方法
var getMethodBuilder = typeBuilder.DefineMethod("get_Name", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.SpecialName | MethodAttributes.Virtual, CallingConventions.Standard, genericTypeBuilder, Type.EmptyTypes);
var getIL = getMethodBuilder.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(getMethodBuilder, interfaceType.GetProperty("Name").GetGetMethod()); //實現對接口方法的重載
propertyBuilder.SetGetMethod(getMethodBuilder); //設置為屬性的get方法
//定義set方法
var setMethodBuilder = typeBuilder.DefineMethod("set_Name", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.SpecialName | MethodAttributes.Virtual, CallingConventions.Standard, null, new Type[] { genericTypeBuilder });
var setIL = setMethodBuilder.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, fieldBuilder);
setIL.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(setMethodBuilder, interfaceType.GetProperty("Name").GetSetMethod()); //實現對接口方法的重載
propertyBuilder.SetSetMethod(setMethodBuilder); //設置為屬性的set方法

 　　(10) 定義並實現PrintName方法

//定義方法
var printMethodBuilder = typeBuilder.DefineMethod("PrintName", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, CallingConventions.Standard, null, Type.EmptyTypes);
var printIL = printMethodBuilder.GetILGenerator();
printIL.Emit(OpCodes.Ldarg_0);
printIL.Emit(OpCodes.Ldflda, fieldBuilder);
printIL.Emit(OpCodes.Constrained, genericTypeBuilder);
printIL.Emit(OpCodes.Callvirt, typeof(object).GetMethod("ToString", Type.EmptyTypes));
printIL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
printIL.Emit(OpCodes.Ret);
//實現對基類方法的重載
typeBuilder.DefineMethodOverride(printMethodBuilder, barType.GetMethod("PrintName", Type.EmptyTypes));

　　(11) 創建類

var type = typeBuilder.CreateType(); //netstandard中請使用CreateTypeInfo().AsType()

　　(12) 調用

var obj = Activator.CreateInstance(type.MakeGenericType(typeof(DateTime)), DateTime.Now);
(obj as Bar).PrintName();
Console.WriteLine((obj as IFoo<DateTime>).Name);

四、應用

　　上面的樣例僅供學習只用，無法運用在實際項目當中，那麼，Emit構建類在實際項目中我們可以有什麼應用，提高我們的編碼效率

　　(1) 動態DTO-當我們需要將實體映射到某個DTO時，可以用動態DTO來代替你手寫的DTO，選擇你需要的字段回傳給前端，或者前端把他想要的字段傳給後端

　　(2) DynamicLinq-我的第一篇博文有個讀者提到了表達式樹，而linq使用的正是表達式樹，當表達式樹+Emit時，我們就可以用像SQL或者GraphQL那樣的查詢語句實現動態查詢

　　(3) 對象合併-我們可以編寫實現一個像js當中Object.assign()一樣的方法，實現對兩個實體的合併

　　(4) AOP動態代理-AOP的核心就是代理模式，但是與其對應的是需要手寫代理類，而Emit就可以幫你動態創建代理類，實現切面編程

　　(5) …

五、小結

　　對於Emit，確實初學者會對其感到複雜和難以學習，但是只要搞懂其中的原理，其實最終就是C#和.NET語言的本質所在，在學習Emit的同時，也是在鍛煉你的基本功是否紮實，你是否對這門語言精通，是否有各種簡化代碼的應用。

　　保持學習，勇於實踐；Write Less，Do More；作者之後還會繼續.NET高級特性系列，感謝閱讀!

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

引言

說到多線程,我覺得我們最重要的是要理解一個臨界區概念。

舉個例子，一個班上1個女孩子（臨界區），49個男孩子（線程），男孩子的目標就是這一個女孩子，就是會有競爭關係（線程安全問題）。推廣到實際場景，例如對一個數相加或者相減等等情形，因為操作對象就只有一個，在多線程環境下，就會產生線程安全問題。理解臨界區概念，我們對多線程問題可以有一個好意識。

Jav內存模型（JMM)

談到多線程就應該了解一下Java內存模型（JMM）的抽象示意圖.下圖：

線程A和線程B執行的是時候，會去讀取共享變量（臨界區），然後各自拷貝一份回到自己的本地內存，執行後續操作。
JMM模型是一種規範，就像Java的接口一樣。JMM會涉及到三個問題：原子性，可見性，有序性。
所謂原子性。就是說一個線程的執行會不會被其他線程影響的。他是不可中斷的。舉個例子:

int i=1

這個語句在Jmm中就是原子性的。無論是一個線程執行還是多個線程執行這個語句，讀出來的i就是等於1。那什麼是非原子性呢，按道理如果Java的代碼都是原子性，應該就不會有線程問題了啊。其實JMM這是規定某些語句是原子性罷了。舉個非原子性例子：

i ++;

這個操作就不是原子性的了。因為他就是包含了三個操作:第一讀取i的值，第二將i加上1，第三將結果賦值回來給i，更新i的值。
所謂可見性。可見性表示如果一個值在線程A修改了，線程B就會馬上知道這個結果。
所謂有序性。所謂有序性值的是語意的有序性。就是說代碼順序可能會發生變化。因為有一個指令重排機制。所謂指令重排，他會改變代碼執行順序，為了讓cpu執行效率更高。為了防止重排序出錯，JMM有個happen-before規則，這個規則限制了那些語句執行在前，那些語句執行在後。
Happen-before：
程序順序原則：一個線程內保證語義的串行性
volatile原則：volatile變量的寫發生在讀之前
鎖規則：先加鎖再解鎖
傳遞性：a先於b，b先於c，則a必定先於c
線程的start方法先於他的每一個操作
線程所有的操作先於線程的終結
對象的構造函數執行、結束先於finalize()方法。

volatile

進入正題，volatile可以保證變量（臨界區）的可見性以及有序性，但是不能保證原子性。舉個例子：

public class VolatileTest implements Runnable{
    private static VolatileTest volatileTest = new VolatileTest();
    private  static volatile int i= 0;
    public static void main(String[] args) throws InterruptedException {
        for (int j = 0; j < 20; j++) {
            Thread a = new Thread(new VolatileTest());
            Thread b = new Thread(new VolatileTest());
            a.start();b.start();
            a.join();b.join();
            System.out.print(i+"&&");
        }

    }
    
    @Override
    public void run() {
        for (int j = 0; j < 1000; j++) {
            i++;
        }
    }

}

// 輸出結果
// 2000&&4000&&5852&&7852&&9852&&11852&&13655&&15655&&17655&&19655&&21306     
//&&22566&&24566&&26189&&28189&&30189&&32189&&34189&&36189&&38089&&

有結果看到有問題，雖然i已經添加了volatile關鍵字，說明volatile關鍵字不能保證i++的原子性。

那什麼場景適合使用volatile關鍵字

1. 輕量級的“讀-寫鎖”策略

private volatile int value;
public int getValue(){ return value;}
public synchronized void doubleValue(){ value = value*value; }

2.單例模式（雙檢查鎖機制

private volatile static Singleton instace;   
public static Singleton getInstance(){  // 沒有使用同步方法，而是同步方法塊
    //第一次null檢查 ，利用volatile的線程間可見性，不需要加鎖，性能提高    
    if(instance == null){            
        synchronized(Singleton.class) {    //鎖住類對象，阻塞其他線程
            //第二次null檢查，以保證不會創建重複的實例       
            if(instance == null){       
                instance = new Singleton(); // 禁止重排序
            }  
        }           
    }  
    return instance;

參考

《現代操作系統（第三版）中文版》
《實戰Java高併發程序設計》
《Java併發編程的藝術》

如果我的文章幫助到您，可以關注我的微信公眾號，第一時間分享文章給您

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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