伊東輝 – ページ 35 – サイゼントの技術ブログ

2020年1月3日

エクスプローラ上でフォルダを任意の順番で並べる

エクスプローラ上でフォルダを任意の順番で並べたい場合、多くの場合は「00_…」「01_…」のような形で番号を割り振り、名前で並び替えると思います。
しかし、フォルダに番号を振らずに作業を進め、既に数多くのリンクが貼られてしまったような状況では、番号を振り直すのが難しくなります。

その場合、更新日時を任意の順番にし、更新日時で並び替えるようにすると良いです。
更新日時を任意の順番にするには、Windows PowerShell を使って自動的で更新日時を更新できるようにすると良いです。
（更新日時が更新されてしまった場合は Windows PowerShell のスクリプトを実行することで更新日時を元に戻す必要は出てきてしまいますが、そこまで面倒ではないと思います）

例えば、以下のようなフォルダ構成になっていて、「hoge」→「fuga」→「piyo」の名前に並び替えたい場合

以下のようなバッチを用意して実行します。

・FolderSort.bat

powershell -ExecutionPolicy RemoteSigned -File .\FolderSort.ps1

1	powershell -ExecutionPolicy RemoteSigned -File .\FolderSort.ps1

・FolderSort.ps1

Set-ItemProperty .\hoge -Name LastWriteTime -Value "2019/12/24 00:00:00"
Set-ItemProperty .\fuga -Name LastWriteTime -Value "2019/12/24 00:01:00"
Set-ItemProperty .\piyo -Name LastWriteTime -Value "2019/12/24 00:02:00"

Set-ItemProperty .\hoge -Name LastWriteTime -Value "2019/12/24 00:00:00"

Set-ItemProperty .\fuga -Name LastWriteTime -Value "2019/12/24 00:01:00"

Set-ItemProperty .\piyo -Name LastWriteTime -Value "2019/12/24 00:02:00"

「FolderSort.bat」をダブルクリックして実行すると更新日時が「hoge」→「fuga」→「piyo」の順番になるように更新され、更新日時で並び替えることで「hoge」→「fuga」→「piyo」の順番になります。

あけましておめでとうございます！

今回は新年ということで、ちょっと軽めというか、小ネタを投稿してみました。
Web検索で良く出てくるのはレジストリを変更する方法とフリーソフトを使用する方法ですが、前者は変更をミスした場合のリスクが大きいですし、後者はセキュリティ上のリスク等が出てしまいます。現場のポリシー次第ではどちらもできないこともあります。
そこで、今回は、更新日時を利用する方法を紹介してみました。
もしお役に立てれば幸いです！

2019年12月29日

javaでのFactory Methodパターン

Factory MethodパターンはTemplate Methodパターンをオブジェクト生成の場面に適用したもので、オブジェクト生成の処理を共通化することができます。

今回は、RPGのキャラクター作成を模したサンプルコードを作成してみました。
キャラクターの職業毎にクラスを分けており、クラス毎に微妙にオブジェクト生成時の処理が異なっていますが、各々のクラスのオブジェクト生成処理を共通化することができています。

【サンプルコード】

・AbstractJob.java

import java.util.ArrayList;
import java.util.List;

public abstract class AbstractJob {

    protected String playerName;
    protected List＜String＞ skillList = new ArrayList&lt;String>();

    public abstract void setPlayerName(String playerName);
    public abstract String getPlayerName();
    public abstract void setSkill(String skill);
    public abstract List＜String＞ getSkill();

}

import java.util.ArrayList;

import java.util.List;

public abstract class AbstractJob {

protected String playerName;

protected List＜String＞ skillList = new ArrayList<String>();

public abstract void setPlayerName(String playerName);

public abstract String getPlayerName();

public abstract void setSkill(String skill);

public abstract List＜String＞ getSkill();

}

・Warrior.java

import java.util.List;

public class Warrior extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class Warrior extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・NormalPerson.java

import java.util.List;

public class NormalPerson extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class NormalPerson extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・AbstractJobFactory.java

public abstract class AbstractJobFactory {

    public final AbstractJob create(String playerName) {
        AbstractJob abstractJob = createJob(playerName);
        return abstractJob;
    }

    protected abstract AbstractJob createJob(String playerName);

}

public abstract class AbstractJobFactory {

public final AbstractJob create(String playerName) {

AbstractJob abstractJob = createJob(playerName);

return abstractJob;

}

protected abstract AbstractJob createJob(String playerName);

}

・WarriorFactory.java

public class WarriorFactory extends AbstractJobFactory {

    protected AbstractJob createJob(String playerName) {
        Warrior warrior = new Warrior();
        warrior.setPlayerName(playerName);
        warrior.setSkill("QuickSlash");
        return warrior;
    }

}

public class WarriorFactory extends AbstractJobFactory {

protected AbstractJob createJob(String playerName) {

Warrior warrior = new Warrior();

warrior.setPlayerName(playerName);

warrior.setSkill("QuickSlash");

return warrior;

}

・NormalPersonFactory.java

public class NormalPersonFactory extends AbstractJobFactory {

    protected AbstractJob createJob(String playerName) {
        NormalPerson normalPerson = new NormalPerson();
        normalPerson.setPlayerName(playerName);
        return normalPerson;
    }

}

public class NormalPersonFactory extends AbstractJobFactory {

protected AbstractJob createJob(String playerName) {

NormalPerson normalPerson = new NormalPerson();

normalPerson.setPlayerName(playerName);

return normalPerson;

}

・CreateJobMain.java

import java.util.Iterator;

public class CreateJobMain {
    public static void main(String[] args){

        // Factoryメソッドの定義
        WarriorFactory warriorFactory = new WarriorFactory();
        NormalPersonFactory normalPersonFactory = new NormalPersonFactory();

        // Factoryメソッドによりオブジェクトを生成
        AbstractJob warrior = warriorFactory.create("Player1");
        AbstractJob normalPerson = normalPersonFactory.create("Player2");

        // 生成されたオブジェクトの内容を確認
        displayJob(warrior);
        displayJob(normalPerson);

    }

    private static void displayJob(AbstractJob player) {
        System.out.println("［プレイヤー："+player.getPlayerName()+"］");
        System.out.println("・職業");
        System.out.println("　"+player.getClass().getName());
        System.out.println("・スキル");
        Iterator&lt;String> iterator = player.getSkill().iterator();
        if (!iterator.hasNext()) {
            System.out.println("　None");
        } else {
            while (iterator.hasNext()) {
                String str = iterator.next();
                System.out.println("　"+str);
            }
        }
    }

}

import java.util.Iterator;

public class CreateJobMain {

public static void main(String[] args){

// Factoryメソッドの定義

WarriorFactory warriorFactory = new WarriorFactory();

NormalPersonFactory normalPersonFactory = new NormalPersonFactory();

// Factoryメソッドによりオブジェクトを生成

AbstractJob warrior = warriorFactory.create("Player1");

AbstractJob normalPerson = normalPersonFactory.create("Player2");

// 生成されたオブジェクトの内容を確認

displayJob(warrior);

displayJob(normalPerson);

}

private static void displayJob(AbstractJob player) {

System.out.println("［プレイヤー："+player.getPlayerName()+"］");

System.out.println("・職業");

System.out.println("　"+player.getClass().getName());

System.out.println("・スキル");

Iterator<String> iterator = player.getSkill().iterator();

if (!iterator.hasNext()) {

System.out.println("　None");

} else {

while (iterator.hasNext()) {

String str = iterator.next();

System.out.println("　"+str);

}

【実行結果】

［プレイヤー：Player1］
・職業
　Warrior
・スキル
　QuickSlash
［プレイヤー：Player2］
・職業
　NormalPerson
・スキル
　None

［プレイヤー：Player1］

・職業

　Warrior

・スキル

　QuickSlash

［プレイヤー：Player2］

・職業

　NormalPerson

・スキル

　None

いかがでしたでしょうか。

前に紹介したTemplate MethodパターンとFactory Methodパターンは似ているので、合わせて覚えておきたいパターンだと思います。
実務でも、「～Factory」という言葉を良く聞きます。「～Factoryはオブジェクトを生成するクラスだ」という知識があるだけでも、開発者同士のコミュニケーションがスムーズになると思います。

では、よいお年を！

2019年12月21日

javaでのTemplate Methodパターン

Template Methodパターンは、処理（メソッド）の中で共通している箇所を抽象クラスとして抜き出すことで、重複した記述を排除し、更に処理の流れも規定する手法のことを指します。
手続き型言語でも共通する箇所を子メソッドとして抜き出すことをしますが、子メソッドとして抜き出してしまうとその子メソッドの使い方までは規定できず、子メソッドを誤った使い方をされてしまう可能性が出てきてしまいます。

サンプルコードとして、RPGのダメージ計算を模したプログラムを作成してみました。
「ベースのダメージ量に対してランダム化を行い最終的なダメージ量とする」という処理の流れを規定できていることがポイントです。

【サンプルコード】

・AbstractDamageCalc.java

import java.util.Random;

public abstract class AbstractDamageCalc {

    public abstract int getDamageBase();

    public final int damageCalc() {
        // ベースのダメージ量に7/8、8/8、9/8の何れかの値をかけてランダム化する
        // 単に共通処理をまとめるだけでなく、共通処理の使い方も指定できる
        // （ランダム化忘れ、ランダム化を２重でする、等を未然に防げる）
        return getDamageBase() * (new Random().nextInt(3) + 7) / 8;
    }
}

import java.util.Random;

public abstract class AbstractDamageCalc {

public abstract int getDamageBase();

public final int damageCalc() {

// ベースのダメージ量に7/8、8/8、9/8の何れかの値をかけてランダム化する

// 単に共通処理をまとめるだけでなく、共通処理の使い方も指定できる

// （ランダム化忘れ、ランダム化を２重でする、等を未然に防げる）

return getDamageBase() * (new Random().nextInt(3) + 7) / 8;

}

・PhysicsDamageCalc.java

public final class PhysicsDamageCalc extends AbstractDamageCalc {

    private int baseDamage = 0;

    public PhysicsDamageCalc(int physicsPower) {
        baseDamage = physicsPower / 2; //攻撃力の半分がダメージ
    }

    public int getDamageBase() {
        return baseDamage;
    }

}

public final class PhysicsDamageCalc extends AbstractDamageCalc {

private int baseDamage = 0;

public PhysicsDamageCalc(int physicsPower) {

baseDamage = physicsPower / 2; //攻撃力の半分がダメージ

}

public int getDamageBase() {

return baseDamage;

}

・MagicDamageCalc.java

public final class MagicDamageCalc extends AbstractDamageCalc {

    private int baseDamage = 0;

    public MagicDamageCalc(int magicID) {
        if (magicID == 0) { //魔法「FireL1」
            baseDamage = 15;
        } else if (magicID == 1) { //魔法「FireL2」
            baseDamage = 60;
        } else if (magicID == 2) { //魔法「FireL3」
            baseDamage = 120;
        } else { //例外処理
            System.out.println("指定された魔法ＩＤは未実装です");
            System.exit(1);
        }
    }

    public int getDamageBase() {
        return baseDamage;
    }

}

public final class MagicDamageCalc extends AbstractDamageCalc {

private int baseDamage = 0;

public MagicDamageCalc(int magicID) {

if (magicID == 0) { //魔法「FireL1」

baseDamage = 15;

} else if (magicID == 1) { //魔法「FireL2」

baseDamage = 60;

} else if (magicID == 2) { //魔法「FireL3」

baseDamage = 120;

} else { //例外処理

System.out.println("指定された魔法ＩＤは未実装です");

System.exit(1);

}

public int getDamageBase() {

return baseDamage;

}

・DamageCalcMain.java

public class DamageCalcMain {
    public static void main(String[] args){

        int physicsPower = -1;
        int magicID = -1;
        int damage = 0;

        // 引数から物理攻撃力、魔法ＩＤを取得
        if (args.length == 2) {
            physicsPower = Integer.parseInt(args[0]);
            magicID = Integer.parseInt(args[1]);
        }

        // ダメージ計算
        if (physicsPower >= 0 || magicID == -1) { //物理攻撃
            damage = new PhysicsDamageCalc(physicsPower)
                              .damageCalc();
        } else if (physicsPower == -1 || magicID >= 0) { //魔法攻撃
            damage = new MagicDamageCalc(magicID)
                              .damageCalc();
        } else { //例外処理
            System.out.println
                ("第１引数：物理攻撃力、魔法攻撃の場合は-1にしてください");
            System.out.println
                ("第２引数：魔法ＩＤ、物理攻撃の場合は-1にしてください");
            System.exit(1);
        }

        System.out.println("ダメージは"+damage);
        System.exit(0);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int physicsPower = -1;

int magicID = -1;

int damage = 0;

// 引数から物理攻撃力、魔法ＩＤを取得

if (args.length == 2) {

physicsPower = Integer.parseInt(args[0]);

magicID = Integer.parseInt(args[1]);

}

// ダメージ計算

if (physicsPower >= 0 || magicID == -1) { //物理攻撃

damage = new PhysicsDamageCalc(physicsPower)

.damageCalc();

} else if (physicsPower == -1 || magicID >= 0) { //魔法攻撃

damage = new MagicDamageCalc(magicID)

.damageCalc();

} else { //例外処理

System.out.println

("第１引数：物理攻撃力、魔法攻撃の場合は-1にしてください");

System.out.println

("第２引数：魔法ＩＤ、物理攻撃の場合は-1にしてください");

System.exit(1);

}

System.out.println("ダメージは"+damage);

System.exit(0);

}

【実行結果】

ダメージは52

ダメージは52

　※第１引数に-1、第２引数に1を指定した場合

いかがでしたでしょうか。

手続き型言語に対するオブジェクト指向型言語の利点として、特定のルールに従ったコーディングを他の開発者にさせやすくなるというものがあり、バグの混入を未然に防ぐことができます。
共通処理の使い方を指定できるTemplate Methodパターンは、その利点が良く分かるパターンの一つだと思います。
抽象クラスの使い方として、このような使い方は覚えておいて損はないと思います。

では、また次回！

2019年12月14日

javaでのFacadeパターン

Facadeクラスとは、使い方が複雑になっているクラス群をまとめ、使いやすい形のインターフェースとして外部に提供するクラスのことを指します。
デザインパターンでは、このFacadeクラスを利用するパターンをFacadeパターンと呼びます。
（ちなみに、Facadeは「窓口」を意味する単語です）

サンプルコードとして、RPGのダメージ計算を模したプログラムを作成してみました。
RPGのダメージ計算は複雑で、そのRPGに詳しくない人が正しく計算式を実装するのは困難なのですが、Facadeクラスを用いることにより、Facadeクラスの利用者は詳しい知識を持たずとも正しく計算式を実装することが可能となります。

【サンプルコード】

・PhysicsBaseDamageCalc.java

public final class PhysicsBaseDamageCalc {

    private int baseDamage = 0;

    public PhysicsBaseDamageCalc(int physicsPower) {
        baseDamage = physicsPower / 2; //攻撃力の半分がダメージ
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class PhysicsBaseDamageCalc {

private int baseDamage = 0;

public PhysicsBaseDamageCalc(int physicsPower) {

baseDamage = physicsPower / 2; //攻撃力の半分がダメージ

}

public int getBaseDamage() {

return baseDamage;

}

・MagicBaseDamageCalc.java

public final class MagicBaseDamageCalc {

    private int baseDamage = 0;

    public MagicBaseDamageCalc(int magicID) {
        if (magicID == 0) { //魔法「FireL1」
            baseDamage = 15;
        } else if (magicID == 1) { //魔法「FireL2」
            baseDamage = 60;
        } else if (magicID == 2) { //魔法「FireL3」
            baseDamage = 120;
        } else { //例外処理
            System.out.println("指定された魔法ＩＤは未実装です");
            System.exit(1);
        }
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class MagicBaseDamageCalc {

private int baseDamage = 0;

public MagicBaseDamageCalc(int magicID) {

if (magicID == 0) { //魔法「FireL1」

baseDamage = 15;

} else if (magicID == 1) { //魔法「FireL2」

baseDamage = 60;

} else if (magicID == 2) { //魔法「FireL3」

baseDamage = 120;

} else { //例外処理

System.out.println("指定された魔法ＩＤは未実装です");

System.exit(1);

}

public int getBaseDamage() {

return baseDamage;

}

・DamageRandomize.java

import java.util.Random;

public final class DamageRandomize {

    private int damage = 0;

    public DamageRandomize(int baseDamage) {
        // 7/8、8/8、9/8の何れかの値をかけてランダム化
        damage = baseDamage * (new Random().nextInt(3) + 7) / 8;
    }

    public int getDamage() {
        return damage;
    }
}

import java.util.Random;

public final class DamageRandomize {

private int damage = 0;

public DamageRandomize(int baseDamage) {

// 7/8、8/8、9/8の何れかの値をかけてランダム化

damage = baseDamage * (new Random().nextInt(3) + 7) / 8;

}

public int getDamage() {

return damage;

}

・DamageCalcFacade.java

public final class DamageCalcFacade {

    private int damage = 0;

    public DamageCalcFacade (int physicsPower,int magicID) {
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
    }

    public int getDamage() {
        return damage;
    }
}

public final class DamageCalcFacade {

private int damage = 0;

public DamageCalcFacade (int physicsPower,int magicID) {

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

}

public int getDamage() {

return damage;

}

・DamageCalcMain.java

public class DamageCalcMain {
    public static void main(String[] args){

        int physicsPower = -1;
        int magicID = -1;
        int damage = 0;

        // 引数から物理攻撃力、魔法ＩＤを取得
        if (args.length == 2) {
            physicsPower = Integer.parseInt(args[0]);
            magicID = Integer.parseInt(args[1]);
        }

        // ダメージ計算→計算式を知らないとこのように実装できない
        /*
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
        */

        // 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる
        damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

        System.out.println("ダメージは"+damage);
        System.exit(0);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int physicsPower = -1;

int magicID = -1;

int damage = 0;

// 引数から物理攻撃力、魔法ＩＤを取得

if (args.length == 2) {

physicsPower = Integer.parseInt(args[0]);

magicID = Integer.parseInt(args[1]);

}

// ダメージ計算→計算式を知らないとこのように実装できない

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

// 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる

damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

System.out.println("ダメージは"+damage);

System.exit(0);

}

【実行結果】

ダメージは52

ダメージは52

　※第１引数に-1、第２引数に1を指定した場合

いかがでしたでしょうか。

デザインパターンはオブジェクト指向プログラミングのプログラミング手法をまとめたものなのですが、このFacadeパターンは手続き型言語にも応用が可能です。
複雑な処理を共通クラス・共通関数・共通スクリプト等のような形で切り出して利用者側に意識させないようにする、というのは現場でも良く使う手法なので、覚えておいて損はありません。

では、また次回！

2019年12月7日

javaでのスレッド制御（joinとsynchronized）

javaでは、スレッドを立てて処理を並列に行うことができます。
しかし、並列に処理を行う際、処理順を制御しなければならないことがあります。

処理順の制御方法として基本的な方法として、joinを使う方法とsynchronizedを使う方法があります。
joinを使うことで、スレッドが終わるのを待つことができます。
また、synchronizedを使うことで、複数のスレッドが同じ処理を同時に行わないように制御することができます。

以下は、joinやsynchronizedを使って制御を行うサンプルコードです。
１つのスレッドで５回の処理を行うサンプルであり、そのスレッドを２つ立てます。
また、スレッド間で同一のオブジェクト（staticなオブジェクト）を共有しており、そのオブジェクトでは合計何回処理が行われたのかをカウントしています。

制御を行わない場合は、どちらのスレッドが先に処理するのかが定まりません。また、共有オブジェクトでのカウントを２つのスレッドで同時に行うためにカウントも上手く行きません。
joinによる制御を行う場合は、スレッド１の５回の処理が終わってからスレッド２の処理に移る、という制御が可能になります。
synchronizedによる制御を行う場合は、スレッド１とスレッド２が同時に動いても、共有オブジェクトでのカウントは同時には行われず、上手くカウントすることができます。

【サンプルコード】

・ThreadMain.java

public class ThreadMain {
    public static void main(String[] args) {

        // スレッドのインスタンスを作成
        ThreadBody test1 = new ThreadBody("スレッド１");
        ThreadBody test2 = new ThreadBody("スレッド２");

        // スレッド１の実行
        test1.start();

        // ①スレッド１が終了するまで待機
        /*
        try {
            test1.join();
        } catch (InterruptedException e) {
            // 例外処理
            e.printStackTrace();
        }
        */

        // スレッド２の実行
        test2.start();
    }
}

public class ThreadMain {

public static void main(String[] args) {

// スレッドのインスタンスを作成

ThreadBody test1 = new ThreadBody("スレッド１");

ThreadBody test2 = new ThreadBody("スレッド２");

// スレッド１の実行

test1.start();

// ①スレッド１が終了するまで待機

try {

test1.join();

} catch (InterruptedException e) {

// 例外処理

e.printStackTrace();

}

// スレッド２の実行

test2.start();

}

・ThreadBody.java

public class ThreadBody extends Thread{

    private String threadName = null;
    private static ThreadCounter threadCounter = new ThreadCounter();

    ThreadBody(String threadName){
        this.threadName = threadName;
    }

    public void run(){
        for (int i = 0; i &lt; 5; i++) {
                threadCounter.countUp();
                System.out.println(threadName+"の"+(i+1)+"回目の処理");
        }
    }
}

public class ThreadBody extends Thread{

private String threadName = null;

private static ThreadCounter threadCounter = new ThreadCounter();

ThreadBody(String threadName){

this.threadName = threadName;

}

public void run(){

for (int i = 0; i < 5; i++) {

threadCounter.countUp();

System.out.println(threadName+"の"+(i+1)+"回目の処理");

}

・ThreadCounter.java

public class ThreadCounter {

    private int count;

    public void countUp() {
        // ②複数スレッドで同時実行されないよう同期を取る
        // synchronized (this) {
            // 1000ミリ秒スリープ
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            System.out.println("処理回数："+count);
        // }
    }
}

public class ThreadCounter {

private int count;

public void countUp() {

// ②複数スレッドで同時実行されないよう同期を取る

// synchronized (this) {

// 1000ミリ秒スリープ

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

count++;

System.out.println("処理回数："+count);

// }

}

【実行結果】

・そのまま実行した場合

処理回数：2
処理回数：2
スレッド１の1回目の処理
スレッド２の1回目の処理
処理回数：3
処理回数：4
スレッド１の2回目の処理
スレッド２の2回目の処理
処理回数：6
処理回数：6
スレッド２の3回目の処理
スレッド１の3回目の処理
処理回数：8
処理回数：8
スレッド２の4回目の処理
スレッド１の4回目の処理
処理回数：10
処理回数：10
スレッド２の5回目の処理
スレッド１の5回目の処理

処理回数：2

スレッド１の1回目の処理

スレッド２の1回目の処理

処理回数：3

処理回数：4

スレッド１の2回目の処理

スレッド２の2回目の処理

処理回数：6

スレッド２の3回目の処理

スレッド１の3回目の処理

処理回数：8

スレッド２の4回目の処理

スレッド１の4回目の処理

処理回数：10

スレッド２の5回目の処理

スレッド１の5回目の処理

・①のコメントアウトを外した場合(join)

処理回数：1
スレッド１の1回目の処理
処理回数：2
スレッド１の2回目の処理
処理回数：3
スレッド１の3回目の処理
処理回数：4
スレッド１の4回目の処理
処理回数：5
スレッド１の5回目の処理
処理回数：6
スレッド２の1回目の処理
処理回数：7
スレッド２の2回目の処理
処理回数：8
スレッド２の3回目の処理
処理回数：9
スレッド２の4回目の処理
処理回数：10
スレッド２の5回目の処理

処理回数：1

スレッド１の1回目の処理

処理回数：2

スレッド１の2回目の処理

処理回数：3

スレッド１の3回目の処理

処理回数：4

スレッド１の4回目の処理

処理回数：5

スレッド１の5回目の処理

処理回数：6

スレッド２の1回目の処理

処理回数：7

スレッド２の2回目の処理

処理回数：8

スレッド２の3回目の処理

処理回数：9

スレッド２の4回目の処理

処理回数：10

スレッド２の5回目の処理

・②のコメントアウトを外した場合(synchronized)

処理回数：1
スレッド１の1回目の処理
処理回数：2
スレッド２の1回目の処理
処理回数：3
スレッド１の2回目の処理
処理回数：4
スレッド２の2回目の処理
処理回数：5
スレッド１の3回目の処理
処理回数：6
スレッド２の3回目の処理
処理回数：7
スレッド１の4回目の処理
処理回数：8
スレッド２の4回目の処理
処理回数：9
スレッド１の5回目の処理
処理回数：10
スレッド２の5回目の処理

処理回数：1

スレッド１の1回目の処理

処理回数：2

スレッド２の1回目の処理

処理回数：3

スレッド１の2回目の処理

処理回数：4

スレッド２の2回目の処理

処理回数：5

スレッド１の3回目の処理

処理回数：6

スレッド２の3回目の処理

処理回数：7

スレッド１の4回目の処理

処理回数：8

スレッド２の4回目の処理

処理回数：9

スレッド１の5回目の処理

処理回数：10

スレッド２の5回目の処理

いかがでしたでしょうか。

性能要件を満たすためにスレッドが必要になることがあるのですが、その際にスレッド制御の方法を知らないと処理の同期が取れずに障害になってしまうことが多いです。
今スレッドを使っていなかったとしても、いつ使うようになるかわかりませんので、こういったスレッド制御の方法を知っておいて損はありません。

では、また次回！