MacにGVMでGradleをインストールする

・ターミナルを開いて下記を入力

> curl -s get.gvmtool.net | bash

・コマンドがインストールできているかを確認

gvm version

・下記コマンドで最新のgradleがインストールされます

> gvm install gradle

・もし、gradleのバージョンを変えたいなら

> gvm list gradle
// 表示されたバージョンを確認して
> gvm install gradle {インストールしたいバージョン}

Java8のlambda式について

Java8が公開されてそれなりに時間が経ちましたが、さすがにそろそろLambda式に慣れないとまずいということでメモとして残していきます。

Java7までの書き方から始まり、徐々にラムダ式の簡略記法に変換していく感じでまとめています。
go1メソッド→go4メソッドまで順序だてる感じで簡略化していきます。
簡略化の仕方に関しては各メソッドにコメントとして記載しているのでそちらを参照してもらえるとわかりやすいかと思います。

package lambda1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;

public class Main {

 private static final List list = Arrays.asList("a", "b", "c", "d",
   "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q",
   "r", "s", "t", "u", "v", "w", "x", "y", "z");

 public static void main(final String[] args) {
  Main m = new Main();
  m.go1();
  m.go2();
  m.go3();
  m.go4();
 }

 /**
  * Java8以前の記述方法。
  * この記述を徐々に簡略化していきます。
  */
 public void go1() {
  System.out.println("go1");
  final List l = new ArrayList(list);
  System.out.println(l.toString());
  l.replaceAll(new UnaryOperator() {

   @Override
   public String apply(String str) {
    return "==" + str;
   }

  });
  System.out.println(l.toString());
 }

 /**
  * replaceAllの引数のUnaryOperatorインタフェースは
  * @FunctionalInterfaceのアノテーションが付いているので、
  * ラムダ式で記述を置き換えられる。
  */
 public void go2() {
  System.out.println("go2");
  final List l = new ArrayList(list);
  System.out.println(l.toString());
  l.replaceAll((String t) -> {
   return "==" + t;
  });
  System.out.println(l.toString());
 }

 /**
  * 処理が1行の場合は{}で囲う必要がないので削除。
  * さらにreturnも1行の場合は削除できるので削除。
  */
 public void go3() {
  System.out.println("go3");
  final List l = new ArrayList(list);
  System.out.println(l.toString());
  l.replaceAll((String t) -> "==" + t);
  System.out.println(l.toString());
 }

 /**
  * 型は推論してくれるし、かつ引数が1個なのでカッコも不要。
  */
 public void go4() {
  System.out.println("go4");
  final List l = new ArrayList(list);
  System.out.println(l.toString());
  l.replaceAll(t -> "==" + t);
  System.out.println(l.toString());
 }
}

しかし、便利ですね。
最初はPHPみたいな矢印マークでとっつきにくかったですが、こうやって徐々に簡略化していくと色々とわかりやすく学べました。
これなら、自分で関数インタフェース(@FunctionalInterface)を利用して、便利に色々と作れる気がしてきました。

ThreadPoolExecutor について(第2部：指定出来るいろいろな機能)

実際に使用したときに、私が悩んだ項目であるコンストラクタ引数と、タスク登録について紹介したいと思います。

■コンストラクタ引数について
ThreadPoolExecutorには下記の4つのコンストラクタがあります。

1.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)
2.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, RejectedExecutionHandler handler)
3.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory)
4.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

コンストラクタ引数のうち、私が特に悩んだRejectedExecutionHandlerについて説明したいと思います。

この値(RejectedExecutionHandler)が何かと言うと、JavaDoc的には下記の様に記述されています。

executor がシャットダウンしている場合、または executor が最大スレッド数とワークキュー容量の両方で有限の境界を使用し、かつ飽和状態である場合、execute(java.lang.Runnable) メソッドで送信された新しいタスクは拒否されます。どちらの場合も、execute メソッドは、RejectedExecutionHandler の RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) メソッドを呼び出します。

要するに、タスク(スレッドで処理されるもの)が処理できなくなった(あふれた)場合に呼び出される処理ということです。
そして、この処理はデフォルトで4種類のポリシーが用意されています。（独自で用意することもできますが）

このポリシーの選択が重要になります！

このポリシーの選択を間違えると、処理して欲しいハズの処理が飛ばされたり、無視されたり、例外を投げられたりすることになります！

なので、このポリシーの選択は慎重に行ってください。

ポリシーは下記の4つが存在します。
ThreadPoolExecutor.AbortPolicy
　RejectedExecutionException をスローする拒否されたタスクのハンドラです。
ThreadPoolExecutor.CallerRunsPolicy
　executor がシャットダウンしていない場合に、execute メソッドの呼び出しで拒否されたタスクを直接実行する、拒否されたタスクのハンドラです。
ThreadPoolExecutor.DiscardOldestPolicy
　executor がシャットダウンしていない場合に、もっとも古い未処理の要求を破棄して execute を再試行する、拒否されたタスクのハンドラです。
ThreadPoolExecutor.DiscardPolicy
　拒否されたタスクを通知なしで破棄する拒否されたタスクのハンドラです。

下の2つ(DiscardOldestPolicy,DiscardPolicy)はタスクを破棄されてしまうので、それで問題ない場合は使用しましょう！
私が使用した時の要件では、絶対にタスクを破棄されてしまっては困るので上の2つ(AbortPolicy,CallerRunsPolicy)のどちらかを使う必要がありました。

私が考えた、この2つのポリシーのメリット・デメリットをまとめます
・CallerRunsPolicy
　メリット
　　タスクがあふれた場合は、親スレッドが処理を行うので効率よくタスクを処理してくれる。
　デメリット
　　スレッドごとにトランザクションを管理している場合に、親スレッドのトランザクションが中断されてしまう可能性がある。
　　（親スレッドは、mainの最初に開始し、mainの最後にかならずトランザクションを終了させたい場合に、親がタスクの処理を行うとタスクの開始時にトランザクションを張ろうとしてネストしたトランザクションになってしまいます。
　　　また、タスクの終了時にトランザクションを閉じるので、mainの最後でトランザクションを終了させることができなくなってしまいます）

・AbortPolicy
　メリット
　　親スレッドはタスクを処理しないので、CallerRunsPolicyのデメリットが発生しない。
　　（この点はDiscardOldestPolicy,DiscardPolicyでも同じことが言えます）
　　デメリットの項目とカブるが、タスクが溢れるようなロジックを作っていた場合に、例外が発生するため、間違に気付ける。
　デメリット
　　タスクがあふれた場合は、例外が発生してしまう。
　　タスクをあふれさせないように、ロジックで制御する必要がある

CallerRunsPolicy、AbortPolicyをこのように分類し、最終的には両方とも使用しました。
トランザクションを考える必要がない場所ではCallerRunsPolicyを使い、そうでない場合はAbortPolicyを使いました。

■タスク登録方法
ThreadPoolExecutorには、タスクとして扱える形式が2つ存在します。
1つ目がRunnableインタフェースを実装する方法、2つ目がCallableインタフェースを実装する方法です。
RunnableインタフェースとCallableインタフェースの簡単な違いは、Callableインタフェースの場合は戻り値を受け取れるということです。
使用用途によって分けるのもいいでしょう！
ただ、RunnableとCallableはタスクの登録方法が若干違うので設計するときは注意しましょう！

・Runnable

1.コンストラクタ引数として渡す、BlockingQueueに格納しておく
2.executeメソッドに引数として渡す
3.submitメソッドに引数として渡す

・Callable

1.submitメソッドに引数として渡す

Runnableの方がいろいろな方法でタスク登録できます。
使用する状況によって分けてみましょう！


こんな感じでThreadPoolExecutorにはいろいろな設定ができるので、
使用用途にあった使い方を吟味してしようしてください。

ThreadPoolExecutor について(第1部：基本的な使い方)

本当に基本的な使い方を紹介します。

■前提条件
スレッド数:3
スレッド消失時間：500ms
スレッド実行される処理(タスク)はRunnableインタフェースを実装させます。
（Callableインタフェースでもできます(タスクの登録方法がRunnableと若干異なります)）

■実ソース

package sample.thread.basic;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class SampleMain {

 public static void main(final String[] args) {
  new SampleMain().go();
 }

 public void go() {
  System.out.println("処理開始");
  final BlockingQueue<Runnable%gt; queue = new LinkedBlockingQueue]<Runnable>();
  // queueに事前に積んでおくこともできる
  for (int i = 0; i < 50; i++) {
   queue.add(new TestRunnable());
  }
  final ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 3, 500, TimeUnit.MILLISECONDS, queue, new ThreadPoolExecutor.CallerRunsPolicy());
  try {
   // shutdown()を呼ぶ前であれば、タスクを後から追加することもできる
   for (int i = 0; i < 50; i++) {
    tpe.execute(new TestRunnable());
   }
  } finally {
   // 必ずshutdownを実行する。実行しないとスレッドが開放されないので処理が一生
   System.out.println("ShutDown実行。");
   tpe.shutdown();
  }
  while (true) {
   if (tpe.isTerminated()) {
    break;
   }
   try {
    System.out.println("タスク終了待ち 1000ms.");
    Thread.currentThread();
    Thread.sleep(1000);
   } catch (InterruptedException ignore) {
   }
  }
  System.out.println("処理終了");
 }

 /**
  * スレッド実行されるタスク。
  */
 private static class TestRunnable implements Runnable {

  private static volatile int count = 0;

  @Override
  public void run() {
   System.out.println(count++);
  }
 }
}

■気をつける点
必ずshutdown()メソッドを呼ぶ必要があります！
これを忘れるとMainスレッドが終了してもスレッドだけプーリングされている状態となり、処理が終わりません。
shutdown()メソッドを実行してもすぐに処理が終了するわけではありません。
すべてのスレッドを正常に処理し終えるまでスレッドは開放されません。
すべてのタスクの処理が終わるのを待ちたいのであれば、終了を待つ必要があります。

ThreadPoolExecutor.terminated()をオーバーライドして、終了処理を書くこともできます。


こんな簡単な記述で、スレッドをプーリングすることができます。
次回は、ThreadPoolExecutorをインスタンス化する際に指定できる、いろいろな機能について触れたいと思います。

ThreadPoolExecutorについて(第0部)

業務でこのクラスを使用する機会があったので、ちょっとまとめておこうと思います。

今回の業務の制約はだいたい下記の通りです。
1.Javaでバッチを作成する必要があった
2.性能を追求する必要があった
3.本番環境のCPUの数が8個あった(もちろんメモリもたくさんありました)

このような条件があったので、スレッドを使用することにしました。
そして、Javaでスレッドを使用するならプーリングして使った方が効率がいいので、プーリング機能を提供しているThreadPoolExecutorを使うことになりました。

今回は、このThreadPoolExecutorを使って実現できたこと、はまったことなどを紹介できたらと思います。

一応、全3部構成(今回を入れると4部ですが)で紹介しようと思います。
構成は下記のような感じで進めようと思います。

第0部
　使ったきっかけ
第1部
　基本的な使い方
第2部
　指定出来るいろいろな機能

では、今日はこの目次で終わります。