Google Code Prettify

顯示具有 Java 標籤的文章。 顯示所有文章
顯示具有 Java 標籤的文章。 顯示所有文章

2018年1月5日 星期五

製作包含 java 的 docker 鏡像

在看完「docker 基本指令」後,我們已經可以製作一個 centos 的鏡像,這篇要在這個鏡像中安裝 Java 9,並且包裝成鏡像。首先下載 Open JDK,下載後我將它放在 /home/steven/Software 目錄下,如下: (openjdk-9.0.1_linux-x64_bin.tar.gz)
接下來 … 要開始了 …
  • docker run -i -t -v /home/steven/Software:/mnt/software centos /bin/bash
下了 docker run 後,因為我之前安裝的 centos 鏡像已經被我移除,在本機找不到後,docker 自動連到 docker hub 再下載一個。這次的 docker run 指令後又多了 -v 參數,這是要掛載磁碟,將本機的 /home/steven/Software 掛載到 centos container 裡的 /mnt/software,所以,在進入 container 後,下 ls -l 指令,又可以看到和本機 /home/steven/Software 一樣的內容。

-i: 即 --interactive, 這個參數要求 docker 保持標準輸入裝置 (stdin)
-t: 即 --tty,這個參數要求 docker 分配一個終端裝置
  •  tar zxvf openjdk-9.0.1_linux-x64_bin.tar.gz -C /usr/local
進入 /mnt/software 目錄後,以上述指令將 open jdk 9 解壓縮到 /usr/local 目錄下,如上圖,可以看到 /usr/local 目錄裡產生了 jdk-9.0.1。
  • ln -s /usr/local/jdk-9.0.1 /usr/bin/java
為了方便存取,建立一個連結到 /usr/bin/java。
  • ./java -version
進入 /usr/bin/java/bin 目錄,下 java -version 指令看一下 jdk 版本,如上,果然是 9.0.1 版。
  • docker ps -a
離開 container 回到本機,下 docker ps -a 看一下剛剛創建的 container,如上圖。
  •  docker commit 87426bc47a5e steven/java9
如上下 docker commit 提交一個鏡像,我們將它命名為 steven/java9 (87426bc47a5e 為 container ID),這個指令執行需要一點點時間,然後提交後顯示出鏡像 ID。
  • docker images
下 docker images 列出所有鏡像,果然可以看到 steven/java9,IMAGE ID 也正確。
  • docker run --rm steven/java9 /usr/bin/java/bin/java -version
使用 docker run 指令啟動剛製作好的鏡像的 container,並且執行該 container 中的 /usr/bin/java/bin/java -version 看看是不是和之前安裝好後執行出來的版本一樣? 如上圖這樣就確認我們確實有安裝好了! --rm 參數是要求 docker 在執行完指令退出 container 後立即刪除該 container。



2015年8月15日 星期六

java.util.concurrent - Future & Callable

在 Java 5 之前,寫多執行緒程式,唯一的辦法就是使用 Thread 類別及 Runnable 介面,Java 5 之後新增加 java.util.concurrent 這個 package,提供了豐富的類別、介面,在這之後 Java 的多執行緒程式設計才真的趨於完整,這篇先介紹 Callable 和 Future,類別圖如下。

在看程式之前,先對上圖說明如下:
  • Callable 介面只定義了一個 call() method,實作這個介面的好處是當執行緒執行結束後,可以傳回值,且值的型別可以由我們自定。 
  • FutureTask 並非 Future 唯一實作的類別,之後還會介紹別的實作 Future 介面的類別,在這篇我先介紹 FutureTask。
接下來看範例程式,這個程式會算出費式數列,傳入的參數是指出程式要列出幾個值,例如傳入 10,則列出 0 1 1 2 3 5 8 13 21 34 共 10 個值。
 1 package idv.steven.concurrency;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.concurrent.Callable;
 6 import java.util.concurrent.ExecutionException;
 7 import java.util.concurrent.FutureTask;
 8 
 9 public class FibonacciDemo implements Callable<List<Long>> {
10     private long number;
11     
12     public FibonacciDemo(long number) {
13         this.number = number;
14     }
15 
16     @Override
17     public List<Long> call() throws Exception {
18         List<Long> fib = new ArrayList<Long>();
19         fib.add(0L);
20         fib.add(1L);
21         for(int i=2; i<number; i++) {
22             Long f = fib.get(fib.size()-1) + fib.get(fib.size()-2);
23             fib.add(f);
24         }
25         
26         return fib;
27     }
28 
29     public static void main(String[] args) {
30         Callable<List<Long>> fibonacci = new FibonacciDemo(10);
31         FutureTask<List<Long>> fibonacciTask = new FutureTask<List<Long>>(fibonacci);
32         
33         Thread t = new Thread(fibonacciTask);
34         t.start();
35         
36         try {
37             t.sleep(10);
38             
39             boolean canceled = fibonacciTask.cancel(false);
40             System.out.println("canceled = " + canceled);
41             
42             if (!fibonacciTask.isCancelled()) {
43                 List<Long> fib = fibonacciTask.get();
44                 for(Long f:fib) {
45                     System.out.print(f + " ");
46                 }
47             }
48             
49 //            if (fibonacciTask.isDone()) {
50 //                List<Long> fib = fibonacciTask.get();
51 //                for(Long f:fib) {
52 //                    System.out.print(f + " ");
53 //                }
54 //            }
55 //            else {
56 //                System.out.println("unfinished");
57 //            }
58         }
59         catch (InterruptedException | ExecutionException  e) {
60             e.printStackTrace();
61         }
62     }
63 }




程式說明如下:

  • FutureTask 有兩個建構式,一個接受實作 Callable 的類別,另一個接受實作 Runnable 的類別,這個程式實作了 Callable (line 9),並指定傳回的值為 List<Long>,也就是所有計算所得的數字。大多數的人會選擇實作 Callable,因為實作 Runnable 的話,還要傳入一個變數,用來儲存傳回值。
  • FutureTask 類別是一個實作 Runnable 介面的類別,要建立執行緒,仍需透過 Thread 類別,所以可以看到第 31 行傳入我們實作 Callable 的類別物件給 FutureTask 後,為了建立一個執行緒,第 33 行再將 FutureTask 類別的物件傳給 Thread,然後在第 34 行啟動一個新的執行緒。
  • 第 17~27 行實作 call() method,計算費式數列後,傳回給主程式。
  • 第 39~47 行及第 49~57 行是不同兩個版本,執行出來的結果是一樣的。
  • 要如何取得 call() method 傳回的值呢? 使用 FutureTask 的 get() method ! 就算是實作 Runnable 介面,也是透過 get() 取得傳回值。(line 43、50)
  • 先說明第一個版本,第 39 行是什麼意思呢? cancel() method 是試著強制中斷 FutureTask 的執行緒! 傳入的參數 true 表示,不管這個執行緒處於什麼狀態,都將它中斷結束,如果傳入的是 false,則是當執行緒已經進入 call() method 且還沒執行完離開 call() method 則不要中斷,否則都中斷。至於傳回值即是 true 表示程式沒有執行完就被中斷,false 則是有執行完。這也是為什麼會有第 37 行睡了 10 毫秒的原因,如果主程式不略微停頓一下,讓 FutureTask 的那個執行緒計算一下費式數列,第 39 行有可能傳回 true,也就是程式被中斷了!
  • 第 42 行判斷是否有被中斷,如果沒有,就是有順利的計算完傳回值,所以第 43 行呼叫 get() 取得傳回值,接下來的 for 迴圈當然就是印出結果。
  • 再來說明第二個版本,同樣的要保留第 37 行,讓費式數列有時間被計算,第 49 行和第 42 行剛好相反,它會判斷執行緒是否有被執行完? 有的話就傳回 true,沒有就傳回 false。傳回 true 的話,第 50 行取得計算結果然後印出來。
Callable 這種會傳回值的架構,在有一個計算很耗時,還蠻好用的,可以先產生一個 Thread 去計算這個值,然後做點別的事,之後再回來取得計算結果。當然,即使用只用 Thread、Runnable 也可以做到同樣的功能,只是會比較麻煩,現在 Java 直接提供相關的 API。

2015年8月13日 星期四

java.util.concurrent.locks - 臨界區間的讀寫

java 在推出時,提供 synchronized、notify、wait 的簡單方式,讓多執行緒程式可以控制臨界區間的存取,到了 Java 5 之後加入  java.util.concurrent 這個 package,又提供了一些 interface (介面) 及 class (類別),這些新的 interface、class 比之前的方法更有彈性、更有效率,這裡簡要的說明 java.util.concurrent.locks 下的主要類別與介面。下圖的 class diagram (類別圖) 僅是主要的 interface、class 及其包含的主要 method,要了解全貌,請參考 Java Documentation

  • ReadWriteLock

ReadWriteLock lock = new ReentrantReadWriteLock();
//...
lock.writeLock().lock(); //取得寫入鎖定
try {
    ...
}
finally {
    lock.writeLock().unlock(); //解除寫入鎖定
}
上面的程式稱不上是一個範例,主要說明使用 ReadWriteLock 的優缺點及注意事項:
  1. 跟 synchronized 比起來,解除了只能針一個 method 或一個 block 設定臨界區間的限制,但是要注意一定要記得 unlock,否則會防礙到其他執行緒進入臨界區間,所以上面的程式,將 unlock() 放在 finally 以確保其最後一定會被執行。
  2. 請回頭看一下類別圖中的 ReadWriteLock,它提供的是有 read lock 和 write lock,這可以改善 synchronized 的效率,synchronized 只要有一個 thread 搶到了 lock,就得等它執行完臨界區間內所有程式,並離開後,其它等著進入臨界區間的 thread 才能進入。現在分出了 read lock 及 write lock,當取得 write lock 的 thread 進入了臨界區間,其它 thread 也只能等待,但是,如果是取得 read lock 的 thread 進入臨界區間,是可以有多個 read lock thread 同時進入,這就改善了效率,又不會讓資料不一致。 
  • Lock
ReentrantLock lock = new ReentrantLock();

try {
    if (lock.tryLock()) {
        //臨界區間 - do something
    }
}
finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}
interface Lock 只有一個實作類別 ReetrantLock,這裡要特別注意 tryLock() 這個 method,它相當有趣,因為當遇到臨界區間時,使用這個 method,如果取得 lock 就傳 true,沒有取得就傳回 false,程式可以依傳回值決定做什麼事,以免有 thread 呆呆的一直等著進臨界區間而浪費時間。
要記得,unlock 前也要先用 isHeldByCurrentThread() 這個 method 判斷一下目前是否有取得 lock,有的話才 unlock。
  • Condition
 前面提到的 lock 是可用來取代 synchronized 的新解法,Condition 的 signal、await 則是與 notify、wait 相當。使用的方法可以參考官網 Condition 的範例如下: 
 1  class BoundedBuffer {
 2    final Lock lock = new ReentrantLock();
 3    final Condition notFull  = lock.newCondition(); 
 4    final Condition notEmpty = lock.newCondition(); 
 5 
 6    final Object[] items = new Object[100];
 7    int putptr, takeptr, count;
 8 
 9    public void put(Object x) throws InterruptedException {
10      lock.lock();
11      try {
12        while (count == items.length)
13          notFull.await();
14        items[putptr] = x;
15        if (++putptr == items.length) putptr = 0;
16        ++count;
17        notEmpty.signal();
18      } finally {
19        lock.unlock();
20      }
21    }
22 
23    public Object take() throws InterruptedException {
24      lock.lock();
25      try {
26        while (count == 0)
27          notEmpty.await();
28        Object x = items[takeptr];
29        if (++takeptr == items.length) takeptr = 0;
30        --count;
31        notFull.signal();
32        return x;
33      } finally {
34        lock.unlock();
35      }
36    }
37  }
這是一個很簡單的"生產者"、"消費者"的例子,當陣列中沒有任何物件時,消費者 (take) 就需等待 (line 27),當陣列滿了時,生產者 (put) 也需等待 (line 13); 如果有新的物件產生生產者會通知消費者 (line 17),如果陣列還有空間,消費者也會通知生產者 (line 31)。
特別注意一下 2~4 行,Condition 是由 lock 的 newCondition() 產生,還有,就如 notify、wait 必需位於 synchronized 區間內一樣,Condition 的 await、signal 也要位於 lock、unlock 之間。




  • StampedLock
前面提到的 ReadWriteLock 可允許多個 readLock 的執行緒同時進入臨界區間,但只允許一個 writeLock 的執行緒進入臨界區間,且當有 writeLock 的執行緒位於臨界區間內,即不允許其它執行緒取得 readLock、writeLock,這會有個問題,當程式有很多讀取的執行緒,只有很少的寫入執行緒,臨界區間大部份時間被取得 readLock  執行緒佔據,寫入的執行緒會很難取得 writeLock 而長期處於等待狀態。為了解決這個問題,Java 8 提供了 StampedLock 這個新類別。
 1 public class BankAccountStampedLock {
 2   private final StampedLock sl = new StampedLock();
 3   private long balance;
 4 
 5   public BankAccountStampedLock(long balance) {
 6     this.balance = balance;
 7   }
 8 
 9   public void deposit(long amount) {
10     long stamp = sl.writeLock();
11     try {
12       balance += amount;
13     } finally {
14       sl.unlockWrite(stamp);
15     }
16   }
17 
18   public void withdraw(long amount) {
19     long stamp = sl.writeLock();
20     try {
21       balance -= amount;
22     } finally {
23       sl.unlockWrite(stamp);
24     }
25   }
26 
27   public long getBalance() {
28     long stamp = sl.readLock();
29     try {
30       return balance;
31     } finally {
32       sl.unlockRead(stamp);
33     }
34   }
35 
36   public long getBalanceOptimisticRead() {
37     long stamp = sl.tryOptimisticRead();
38     long balance = this.balance;
39     if (!sl.validate(stamp)) {
40       stamp = sl.readLock();
41       try {
42         balance = this.balance;
43       } finally {
44         sl.unlockRead(stamp);
45       }
46     }
47     return balance;
48   }
49 }
這是一個存、提款的範例程式,來源是 javaspecialists 網站。這個程式和完全只使用 ReadWriteLock 最大差別在於 getBalanceOptimisticRead(),第 37 行先呼叫 tryOptimisticRead 取得一個樂觀讀取鎖定,第 38 行取得存款餘額,第 39 行判斷看看是否在取得樂觀讀取鎖定後,有臨界區間有取得寫入鎖定的執行緒進入,沒有的話,直接回傳存款餘額 (line 47),萬一有的話,balance 的值有可能已經被改變,所以就要謹慎的取得讀取鎖定 (line 40),再取得真正最新的值後再解鎖 (line 44)。

2015年7月22日 星期三

NIO.2: 目錄的處理

檔案系統的 I/O,除了前幾篇所說明的檔案相關處理外,另一個主題就是目錄的處理 - 讀取、走訪、過濾檔案等,說明如下:
  • 取得根目錄
 1 package idv.steven.nio2.filedir;
 2 
 3 import static java.lang.System.out;
 4 import java.nio.file.FileSystems;
 5 import java.nio.file.Path;
 6 import java.util.ArrayList;
 7 
 8 public class ListRoots {
 9 
10     public static void main(String[] args) {
11         Iterable<Path> dirs = FileSystems.getDefault().getRootDirectories();
12         
13         ArrayList<Path> list = new ArrayList<Path>();
14         for(Path name : dirs) {
15             list.add(name);
16         }
17         Path[] array = new Path[list.size()];
18         list.toArray(array);
19         
20         for(Path path : array) {
21             System.out.println(path);
22         }
23         
24         //dirs.forEach(out::println); //Java 8
25     }
26 }
如上的程式,第 11 行可以取得檔案系統的根目錄,在單根檔案系統,例如 Unix/Linux,當然就只會輸出 /,在 Windows 上執行,就看作業系統裡有幾個磁碟,像是我的電腦,執行出來就會是 .....
C:\
D:\
E:\
F:\
H:\
程式 13~22 行是傳統 Java 的寫法,使用 Lambda 的話,只要第 24 行這樣一行程式就可以了。
  • 檢查檔案或目錄是否存在? 
 1 package idv.steven.nio2.filedir;
 2 
 3 import java.nio.file.FileSystems;
 4 import java.nio.file.Files;
 5 import java.nio.file.LinkOption;
 6 import java.nio.file.Path;
 7 
 8 public class CheckExist {
 9     public static void main(String[] args) {
10         Path path = FileSystems.getDefault().getPath("D:/TEST");
11         boolean isNotExist = Files.notExists(path, new LinkOption[] {LinkOption.NOFOLLOW_LINKS});
12         System.out.println(isNotExist);
13     }
14 }
不管是檢查檔案或目錄是否存在,使用的方法是一樣的,上面的程式是檢查 D:/ 下是否有 TEST 這個子目錄,注意看一下第 11 行,這裡使用的是 notExists 這個 method,Files 類別也提供有 exists method,notExists 就等於 !exists。
  • 讀取目錄
 1 package idv.steven.nio2.filedir;
 2 
 3 import java.io.IOException;
 4 import java.nio.file.DirectoryStream;
 5 import java.nio.file.Files;
 6 import java.nio.file.Path;
 7 import java.nio.file.Paths;
 8 
 9 public class ListDirectory {
10 
11     public static void main(String[] args) {
12         Path path = Paths.get("/home/steven/TEST");
13         try (DirectoryStream<Path> ds = Files.newDirectoryStream(path, "[rR]eadme*.txt")) {
14             for(Path file : ds) {
15                 System.out.println(file.getFileName());
16             }
17         }
18         catch (IOException e) {
19             System.err.println(e);
20         }
21     }
22 }
如上是 java.nio 提供的讀取目錄內容的方法之一,第二個參數不填,則會列出目錄裡的所有檔案、子目錄、連結等所有內容。第二個參數有那些選項呢? 如下:
  1. *: 比對所有字元。
  2. **: 跨目錄比對所有字元。
  3. ?: 比對一個字元,如果用這個選項,例如: a?.txt,那麼就一定是 a 後面要接一個字元,a.txt 不算在這個條件裡。
  4. { }: 比對大括號內所有 pattern,例如: {a?.txt, *.jpg},那麼可能就會列出 ab.txt、face.jpg、leg.jpg …
  5. [ ]: 比對中括號內所有列出的字元,像是上面的程式,會找出 readme*.txt 及 Readme*.txt 的檔案,中括號內,可以放入如下選項:
(1) [0-9]: 0 到 9 的所有數字,當然,也可以是[3-7],只搜尋 3 到 7 的數字。
(2) [A-Z]: 大寫 A 到 Z。
(3) [a-z,A-Z]: 大小寫的所有英文字母。
(4) [2345RT]: 比對到括號中任一字元。
6. 大括號、中括號內也可以有 *、? 等萬用字元,並複合使用,例如: {*[0-9].jpg},輸出的結果可能就會是 face1.jpg、leg3.jpg …
  •  走訪目錄
上面的說明有提到讀取目錄的方法,如果我們要走訪目錄呢? java.nio 提到了一個介面 FileVisitor,實作這個介面後,會有四個 callback method,在走訪時,java.nio 會在各個時間點呼叫這四個 method,讓我們可以進行各種處理,四個介面說明如下:
  1. preVisitDirectory: 走訪一個目錄前。
  2. postVisitDirectory: 走訪一個目錄之後。
  3. visitFile: 走訪一個檔案時。
  4. visitFileFailed: 走訪檔案失敗,通常是因為無存取權限。
接下來看一下程式:
 1 package idv.steven.nio2.filedir;
 2 
 3 import java.io.IOException;
 4 import java.nio.file.FileVisitResult;
 5 import java.nio.file.FileVisitor;
 6 import java.nio.file.Files;
 7 import java.nio.file.Path;
 8 import java.nio.file.Paths;
 9 import java.nio.file.attribute.BasicFileAttributes;
10 import static java.nio.file.FileVisitResult.*;
11 
12 public class WalkFolder implements FileVisitor<Path> {
13 
14     @Override
15     public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
16             throws IOException {
17         
18         System.out.println("preVisitDirectory: " + dir.getFileName());
19 
20         return CONTINUE;
21     }
22 
23     @Override
24     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
25             throws IOException {
26         
27         System.out.println("visitFile: " + file.getFileName());
28         
29         return CONTINUE;
30     }
31 
32     @Override
33     public FileVisitResult visitFileFailed(Path file, IOException exc)
34             throws IOException {
35         
36         System.out.println("visitFileFailed: " + file.getFileName());
37         
38         return CONTINUE;
39     }
40 
41     @Override
42     public FileVisitResult postVisitDirectory(Path dir, IOException exc)
43             throws IOException {
44 
45         System.out.println("postVisitDirectory: " + dir.getFileName());
46         
47         return CONTINUE;
48     }
49     
50     public static void main(String[] args) throws IOException {
51         WalkFolder walkFolder = new WalkFolder();
52         
53         Files.walkFileTree(Paths.get("D:/TEST"), walkFolder);
54     }
55 }
這個程式會走訪 D:/TEST  下的所有子目錄及檔案,在 method 中可進行需要的處理,特別要提出來說明的是返回值,上面四個 method 都返回 CONTINE,表示繼續走訪,java.nio 提供了四個返回值,如下:
  1. CONTINUE: 繼續走訪
  2. SKIP_SIBLINGS: 跳過同一階層的檔案或子目錄後繼續走訪
  3. SKIP_SUBTREE: 跳過正走訪的這個目錄後繼續走訪
  4. TERMINATE: 停止走訪
在許多的情況下,我們並不會需要同時實作四個 method,所以 java.nio 提供了一個 SimpleFileVisitor 類別,繼承這個類別,我們只需要 override 要特別處理的 method,這樣會方便些。

  • 拷貝、搬移、刪除
 1 package idv.steven.nio2.action;
 2 
 3 import java.io.IOException;
 4 import java.nio.file.Files;
 5 import java.nio.file.Path;
 6 import java.nio.file.Paths;
 7 
 8 public class Copy {
 9 
10     public static void main(String[] args) throws IOException {
11         Path from = Paths.get("D:/TEST/readme.txt");
12         Path to = Paths.get("D:/readme.txt");
13         Files.copy(from, to);
14     }
15 }
上面的程式,很簡單的都用預設值,將檔案由 from 拷貝一份到 to,Files.copy(...) 是可以帶參數,以指出要如何拷貝檔案,例如將它改寫如下:
import static java.nio.file.StandardCopyOption.*;
import static java.nio.file.LinkOption.*;
…
Files.copy(from, to, REPLACE_EXISTING, COPY_ATTRIBUTES, NOFOLLOW_LINKS);
第三個參數指出檔案的屬性也要拷貝到新檔,第四個參數則指出,如果這個檔案是 symbol link 就不要拷貝,這些參數定義在 StandardCopyOption 及 LinkOption 套件中。同樣的程式,可以用來拷貝目錄嗎? 可以,不過,目錄下的檔案不會被拷貝。Files 這個類別還提供有 move、delete 等 method,可以用來搬移、刪除檔案、目錄,詳細可以參考 Java Doc。