路地裏

Javaのスレッド処理に関するメモ。
呼び出す側だけを変更すれば対応可能です。
今回の例では1ファイルをタスクに渡しているので、
大量ファイルで1ファイル内のレコード量が少ない時に効果が出ます。
1ファイルで1ファイル内のレコード量が多い場合、タスクに渡す単位を考えた方が良いです。

• 呼び出す側

  public static void main(String[] args) {
      Z_Thread main = new Z_Thread();
      // スレッド管理サービスを生成する。
      ExecutorService multiExecutor = Executors.newFixedThreadPool(2);
      main.executeMultiTask(multiExecutor);
      // スレッドを終了する。
      multiExecutor.shutdown();
  }
  

  private void executeMultiTask(ExecutorService serviceExecutor) {
      // 戻り値を定義する。
      List<Future<Long>> futures = new ArrayList<Future<Long>>();
      Future<Long> future = null;
      try {
          String fileDir = "D:\\";
          String fileName = "";
          // 指定ディレクトリの「*.txt」の一覧を取得する。
          Path path = Paths.get(fileDir);
          try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path, "*.txt")) {
              // 指定ディレクトリの「*.txt」数分繰り返す。
              for (Path p : directoryStream) {
                  // ファイル名を取得する。
                  fileName = p.getFileName().toString();
                  // 取得したファイル名をタスクに登録する。
                  // タスクはCallableを利用することで戻り値と例外を受け取れるようにする。
                  // タスクはRunnableを利用すると戻り値と例外は受け取れない。
                  Future<Long> future = serviceExecutor.submit(new CallableTest(fileDir, fileName));
                  futures.add(future);
              }
          } catch (IOException e) {
              System.out.println("IO例外");
          }
          // 結果を順次取得する。
          for (Future<Long> futureResult : futures) {
              Long result = futureResult.get(20000, TimeUnit.MILLISECONDS);
              System.out.println("結果：" + result + "：スレッドの結果を受け取りました。");
          }
      } catch (InterruptedException e){
          System.out.println("割り込み例外");
      } catch (ExecutionException e) {
          System.out.println("タスクの中で例外発生");
      } catch (TimeoutException e) {
          System.out.println("タイムアウト例外発生");
      } catch (Exception e) {
          System.out.println("何かの例外発生")
      } finally {
          future.cancel(true);
      }
  }
  

Javaのスレッド処理に関するメモ。
JDK1.4ではThreadを利用していたが、JDK1.5以降はExecutorServiceを利用する。

• 呼び出す側

  public static void main(String[] args) {
      Z_Thread main = new Z_Thread();
      // スレッド管理サービスを生成する。
      ExecutorService singleExecutor = Executors.newSingleThreadExecutor();
      main.executeSingleTask(singleExecutor);
      // スレッドを終了する。
      singleExecutor.shutdown();
  }
  

  private void executeSingleTask(ExecutorService serviceExecutor) {
      // 戻り値を定義する。
      Future<Long> future = null;
      try {
          String fileDir = "D:\\";
          String fileName = "";
          // 指定ディレクトリの「*.txt」の一覧を取得する。
          Path path = Paths.get(fileDir);
          try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path, "*.txt")) {
              // 指定ディレクトリの「*.txt」数分繰り返す。
              for (Path p : directoryStream) {
                  // ファイル名を取得する。
                  fileName = p.getFileName().toString();
                  // 取得したファイル名をタスクに登録する。
                  // タスクはCallableを利用することで戻り値と例外を受け取れるようにする。
                  // タスクはRunnableを利用すると戻り値と例外は受け取れない。
                  future = serviceExecutor.submit(new CallableTest(fileDir, fileName));
                  // Futureクラスのgetメソッドを呼び出すと呼び出し側は結果が返ってくるまで処理を止める。
                  // 20秒を過ぎるとタイム例外が返ってくる。
                  Long result = future.get(20000, TimeUnit.MILLISECONDS);
                  System.out.println("結果：" + result + "：スレッドの結果を受け取りました。");
              }
          }
      } catch (InterruptedException e){
          System.out.println("割り込み例外");
      } catch (ExecutionException e) {
          System.out.println("タスクの中で例外発生");
      } catch (TimeoutException e) {
          System.out.println("タイムアウト例外発生");
      } catch (Exception e) {
          System.out.println("何かの例外発生");
      } finally {
          future.cancel(true);
      }
  }
  

• 呼び出される側(タスク)(Callableを利用する)

  private String fileDir = "";
  private String fileName = "";
  
  public CallableTest(String fileDir, String fileName) {
      this.fileDir = fileDir;
      this.fileName = fileName;
  }
  
  public Long call() throws Exception {
      try {
          System.out.println(Thread.currentThread().getId() + "：スレッド処理開始");
          if (Thread.currentThread().isInterrupted()) {
              System.out.println("スレッドに割り込みありました。");
              throw new InterruptedException("割り込み例外");
          }
  
          // 何かの処理を想定
          Thread.sleep(10000);
          // コンストラクタで指定したファイルの内容を読み取り表示する。
          List<String> line = Files.readAllLines(Paths.get(fileDir, fileName), Charset.forName("UTF-8"));
          System.out.println(Thread.currentThread().getId() + "：" + fileName + "の内容を表示");
          for (String str : line) {
              System.out.println(str);
          }
      } catch(Exception e){
          System.out.println(Thread.currentThread().getId() + "エラー検知");
          throw e;
      } finally {
          System.out.println(Thread.currentThread().getId() + "：スレッド処理終了");
      }
      return Thread.currentThread().getId();
  }
  

• log4jの取得
  Javaでlog4jを利用します。
  log4jも1.xと2.xでバージョンがありますが
  2015年8月で1.xの開発は終わっており、
  今は2.xの利用が推奨されています。

  log4j2.xの最新版は以下のサイトの(binary (zip))から入手します。
  http://logging.apache.org/log4j/2.x/download.html

  zipファイルを解凍後、以下のjarをクラスパスに通します。
  log4j-api-2.x.jarとlog4j-core-2.x.jar

• log4jの設定ファイル
  log4j1.xではlog4j.propertiesだったようですが、
  log4j2.xではlog4j.xmlを利用します。

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE project>  
  <Configuration status="off">
  
  <Properties>
      <Property name="format1">%d{yyyy/MM/dd HH:mm:ss.SSS} [%t] [%p] [%c] %m%n</Property>
      <Property name="logfile">D:/test.log</Property>
      <Property name="logfile-archive">D:/test_%d{yyyy-MM-dd}-%i.log</Property>
      <!-- %dは日時。{}に日時の形式を指定 -->
      <!-- %tはスレッド名 -->
      <!-- %pはログレベル名(TRACE, ERROR) -->
      <!-- %cはロガーを生成したクラスフルパス -->
      <!-- %mはログメッセージ -->
      <!-- %nは改行 -->
      <!-- 出力イメージ
           2017/06/25 14:54:20.068 [pool-1-thread-1] [TRACE] [thread.Log] 10：処理開始
           2017/06/25 14:54:20.070 [pool-1-thread-1] [TRACE] [thread.Log] 10：処理終了
      -->
  </Properties>
  
  <Appenders>
      <!-- コンソール出力設定 -->
      <Console name="Console" target="SYSTEM_OUT">
          <PatternLayout>
              <pattern>${format1}</pattern>
          </PatternLayout>
      </Console>
  
      <!-- ファイル出力設定 -->
      <RollingFile name="logfile001" append="true" fileName="${logfile}" filePattern="${logfile-archive}">
          <PatternLayout>
              <pattern>${format1}</pattern>
          </PatternLayout>
          <Policies>
              <!-- 1KBを超えたらローテーション -->
              <SizeBasedTriggeringPolicy size="1KB"/>
              <!-- 日付でローテーション -->
              <TimeBasedTriggeringPolicy />
          </Policies>
          <!-- ローテーションファイルの圧縮率や削除タイミング -->
          <DefaultRolloverStrategy max="3"/>
      </RollingFile>
  </Appenders>
  
  <Loggers>
      <!-- nameは任意の名前かパッケージ名(hoge.fuga.sample)を指定する -->
      <!-- 任意の名前の場合、JavaでLoggerを生成する際にコンストラクタで指定する -->
      <!-- additivityは上位のロガーにもログを出力するかどうか。デフォルトはtrue -->
      <Logger name="WEB" level="info" additivity="false">
          <AppenderRef ref="logfile001" />
      </Logger>
      <Root level="trace">
          <AppenderRef ref="Console" />
      </Root>
  </Loggers>
  
  </Configuration>
  

• log4jの利用

  package thread;
  public class Log {
  
      private Logger logger = null;
      private massage = "";
  
      public Log() {
          logger = LogManager.getLogger();
      }
  
      public void writeInfoLog(String message) {
          // messageIDを引数として、メッセージ内容を取得する方法が良い。
          logger.trace(Thread.currentThread().getId() + ":" + message);
      }
  }
  

  package thread;
  public class CallableTest implements Callable<Integer> {
  
      private Log logger = new Log();
      private Log loggerWeb = new Log("WEB");
  
      public Integer call() throws Exception {
          logger.writeInfoLog("ログ");
          loggerWeb.writeInfoLog("ログ");
      }
  }
  

Javaで外部プロセス(外部のexeファイル)を起動します。
外部プロセスとはxcopyコマンドやffmpegコマンド等です。

例として、ffmpegでmp4をmp3に変換します。
ffmpegは最新版zipを解凍後のフォルダ(D:/DownloadFiles/freesoft/ffmpeg.exe)に存在し、
パスは通していないものとします。

• 外部プロセス起動設定

  // 外部プロセスの起動のためのコマンドを設定する。
  // Listに設定するものはスペースを含めないように設定する。
  // 今回の例では「D:/DownloadFiles/freesoft/ffmpeg -i D:/test.mp4 -ab 128 D:/test.mp3」となる。
  String mp4File = "D:/test.mp4";
  String mp3File = "D:/test.mp3";
  List<String> cmd = new ArrayList<String>();
  // 「cmd /C」は必要に応じて設定する。
  // echoのようにコマンドプロントが解釈するコマンドを実行する場合に有効です。
  // cmd.add("cmd"); // コマンドプロンプトを起動する。
  // cmd.add("/C"); // コマンドを実行した後に終了を指定する。
  cmd.add("D:/DownloadFiles/freesoft/ffmpeg");
  cmd.add("-i");
  cmd.add(mp4File);
  cmd.add("-ab");
  cmd.add("128");
  cmd.add(mp3File);
  ProcessBuilder processBuilder = new ProcessBuilder(cmd);
  // 標準エラーを標準出力にマージする。
  processBuilder.redirectErrorStream(true);
  

• 外部プロセス起動その１
  JDK1.7以上であれば今回の方法を選択すると
  外部プロセスの標準エラーを標準出力にマージする設定を活かしつつ、
  出力先を呼び出し側のJavaプロセスに設定できます。

  // 標準出力(標準エラー含む)の内容の出力先をJavaプロセスと同一にする。
  processBuilder.inheritIO();
  // 外部プロセスを起動する。
  Process process = processBuilder.start();
  // 外部プロセスの終了を待機する。
  // この設定を行わないと、「while ((line = br.readLine()) != null)」がないため、
  // Javaプロセスの方が先に処理が進み、「process.exitValue();」で
  // 「process has not exited」というエラーになります。
  process.waitFor();
  // 外部プロセスの結果を出力する。
  int ret = process.exitValue();
  System.out.println("結果：" + ret);
  

• 外部プロセス起動その２
  外部プロセスの標準エラーを標準出力にマージする設定を活かしつつ、
  出力先を別ファイルに指定できます。

  // 標準出力(標準エラー含む)の内容の出力先を別ファイルに指定する。
  processBuilder.redirectOutput(new File("D:/process.log"));
  // 外部プロセスの終了を待機する。
  process.waitFor();
  // 外部プロセスの結果を出力する。
  int ret = process.exitValue();
  System.out.println("結果：" + ret);
  

• 外部プロセス起動(非推奨な方法１)
  この方法の欠点として、InputStreamは1024バイトを超える量が保持できないため、
  ロック状態になる可能性があるようです。
  JavaAPIの仕様にも記載があります。

  // 外部プロセスを起動する。
  Process process = processBuilder.start();
  // 標準出力と標準エラーを受け取る。
  InputStream inputStream = process.getInputStream();
  // 受け取ったInputStreamを出力し、外部プロセスの結果を出力する。
  BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
  String line = null;
  while ((line = br.readLine()) != null) {
      System.out.println(line);
  }
  int ret = process.exitValue();
  System.out.println("結果：" + ret);
  

• 外部プロセス起動(非推奨な方法２)
  JDK1.4まではRuntimeで起動させていたようですが、
  JDK1.5からはProcessBuilderが内部的にRuntimeを呼び出しているのと、
  標準エラーの内容を標準出力にマージできるようになったりとしているため、
  以下の呼び出し方法は非推奨なようです。

  String cmd = "D:/DownloadFiles/freesoft/ffmpeg -i " + mp4File + " -ab 128 " + mp3File;
  Process process = Runtime.getRuntime().exec(cmd);