Java : Thread (スレッド) - API使用例

Thread (Java SE 17 & JDK 17) の使用例まとめです。
だいたいのメソッドを網羅済みです。
API仕様のおともにどうぞ。


概要

クラス構成

Threadクラスは、スレッドを扱う低レイヤのAPIです。
きめ細やかなスレッドの制御が可能です。

しかし、一般的なプログラムでは、高レイヤのAPIである ExecutorServiceStream のparalellメソッドを使うことをおすすめします。

同期(synchronized)については「synchronizedの多いコードは危険信号」もご参照いただけたら幸いです。

Chapter 17. Threads and Locks

スレッドについては、上記の言語仕様も合わせてご確認ください。

フィールド

static final int MAX_PRIORITY

スレッドに設定できる最高優先順位です。

System.out.println(Thread.MAX_PRIORITY); // 10

static final int MIN_PRIORITY

スレッドに設定できる最低優先順位です。

System.out.println(Thread.MIN_PRIORITY); // 1

static final int NORM_PRIORITY

スレッドに割り当てられるデフォルトの優先順位です。

System.out.println(Thread.NORM_PRIORITY); // 5

コンストラクタ

Thread ()

新しいThreadオブジェクトを割り当てます。

class SampleThread extends Thread {
    @Override
    public void run() {
        System.out.println("Run!");

        System.out.println("name : " + getName());
        System.out.println("priority : " + getPriority());
        System.out.println("group : " + getThreadGroup().getName());
        System.out.println("daemon : " + isDaemon());
    }
}

final var thread = new SampleThread();

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//name : Thread-3
//priority : 5
//group : main
//daemon : false
//-- join --

Thread (Runnable target)

新しいThreadオブジェクトを割り当てます。

final Runnable target = () -> {
    System.out.println("Run!");

    final var current = Thread.currentThread();
    System.out.println("current : " + current);
};

final var thread = new Thread(target);

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[Thread-3,5,main]
//-- join --

Thread (Runnable target, String name)

新しいThreadオブジェクトを割り当てます。

final Runnable target = () -> {
    System.out.println("Run!");

    final var current = Thread.currentThread();
    System.out.println("current : " + current);
};

final var thread = new Thread(target, "name-A");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[name-A,5,main]
//-- join --

Thread (String name)

新しいThreadオブジェクトを割り当てます。

final var thread = new Thread("name-A") {
    @Override
    public void run() {
        System.out.println("Run!");

        final var current = Thread.currentThread();
        System.out.println("current : " + current);
    }
};

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[name-A,5,main]
//-- join --

Thread (ThreadGroup group, Runnable target)

新しいThreadオブジェクトを割り当てます。

final var group = new ThreadGroup("group-A");

final Runnable target = () -> {
    System.out.println("Run!");

    final var current = Thread.currentThread();
    System.out.println("current : " + current);
};

final var thread = new Thread(group, target);

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[Thread-3,5,group-A]
//-- join --

Thread (ThreadGroup group, Runnable target, String name)

その実行オブジェクトとしてtarget、名前として指定されたnameを持つ、groupによって参照されるスレッド・グループに属するような、新しいThreadオブジェクトを割り当てます。

final var group = new ThreadGroup("group-A");

final Runnable target = () -> {
    System.out.println("Run!");

    final var current = Thread.currentThread();
    System.out.println("current : " + current);
};

final var thread = new Thread(group, target, "name-A");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[name-A,5,group-A]
//-- join --

Thread (ThreadGroup group, Runnable target, String name, long stackSize)

新しいThreadオブジェクトを割り当て、実行オブジェクトとしてtargetを保持し、指定されたnameを名前として保持するようにします。また、groupによって参照されるスレッド・グループに所属し、指定されたスタック・サイズを保持します。

stackSize 以外は Thread(ThreadGroup group, Runnable target, String name) と同等です。
そちらのAPI使用例もご参照ください。

runTest(1);

// 結果
// ↓
//-- start --
//Run!
//StackOverflowError!
//-- join --

runTest(10000000);

// 結果
// ↓
//-- start --
//Run!
//OK!
//-- join --
public void runTest(int stackSize) throws InterruptedException {
    final Runnable target = () -> {
        System.out.println("Run!");

        try {
            recursive(0);
            System.out.println("OK!");
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError!");
        }
    };

    final var thread = new Thread(null, target, "", stackSize);

    System.out.println("-- start --");
    thread.start();

    thread.join();
    System.out.println("-- join --");
}

// StackOverflowErrorを意図的に起こすための再帰メソッドです。
public void recursive(int i) {
    if (i > 100000) {
        return;
    }

    recursive(i + 1);
}

Thread (ThreadGroup group, Runnable target, String name, long stackSize, boolean inheritThreadLocals)

オブジェクトとしてtargetを持ち、指定されたnameをその名前とし、groupによって参照されるスレッド・グループに属し、指定されたstackSizeを持ち、inheritThreadLocalsがtrueなら「継承可能なスレッド・ローカル」変数の初期値を継承するように、新しいThreadオブジェクトを割り当てます。

inheritThreadLocals 以外は Thread(ThreadGroup group, Runnable target, String name, long stackSize) と同等です。
そちらのAPI使用例もご参照ください。

runTest(true);

// 結果
// ↓
//parent get : abcd
//child get : abcd

// ※threadLocalの値が子スレッドに継承されます。

runTest(false);

// 結果
// ↓
//parent get : abcd
//child get : null

// ※threadLocalの値が子スレッドに継承されません。
public void runTest(boolean inheritThreadLocals) throws InterruptedException {

    final var threadLocal = new InheritableThreadLocal<String>();

    final Runnable target = () -> {
        threadLocal.set("abcd");

        System.out.println("parent get : " + threadLocal.get());

        final var childThread = new Thread(null, () -> {
            System.out.println("child get : " + threadLocal.get());

        }, "name-A", 0, inheritThreadLocals);

        try {
            childThread.start();
            childThread.join();

        } catch (InterruptedException e) {
            System.out.println("Interrupted!");
        }
    };

    final var parentThread = new Thread(target);

    parentThread.start();
    parentThread.join();
}

Thread (ThreadGroup group, String name)

新しいThreadオブジェクトを割り当てます。

final var group = new ThreadGroup("group-A");
final var name = "name-A";

final var thread = new Thread(group, name) {
    @Override
    public void run() {
        System.out.println("Run!");

        final var current = Thread.currentThread();
        System.out.println("current : " + current);
    }
};

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//current : Thread[name-A,5,group-A]
//-- join --

メソッド

static int activeCount ()

現在のスレッドのスレッド・グループとそのサブグループに含まれるアクティブ・スレッドの推定数を返します。

final var groupA = new ThreadGroup("group-A");
final var groupB = new ThreadGroup("group-B");

final var thread = new Thread(groupA, () -> {
    final var current = Thread.currentThread();
    System.out.println(current.getThreadGroup().getName());
    System.out.println("activeCount : " + Thread.activeCount());

    final Runnable target = () -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted!");
        }
    };

    try {
        final var t1 = new Thread(target);
        t1.start();
        System.out.println(t1.getThreadGroup().getName());
        System.out.println("activeCount : " + Thread.activeCount());

        final var t2 = new Thread(target);
        t2.start();
        System.out.println(t2.getThreadGroup().getName());
        System.out.println("activeCount : " + Thread.activeCount());

        // グループを別にするとカウントされません。
        final var t3 = new Thread(groupB, target);
        t3.start();
        System.out.println(t3.getThreadGroup().getName());
        System.out.println("activeCount : " + Thread.activeCount());

        t1.join();
        t2.join();
        t3.join();

    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    }
});

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//group-A
//activeCount : 1
//group-A
//activeCount : 2
//group-A
//activeCount : 3
//group-B
//activeCount : 3
//-- join --

final void checkAccess ()

削除予定のため非推奨: このAPI要素は、将来のバージョンで削除される可能性があります。

非推奨です。

protected Object clone ()

Threadを意味のあるかたちで複製することは不可能なため、CloneNotSupportedExceptionをスローします。

final var thread = new Thread() {
    @Override
    public void run() {
        try {
            System.out.println("Run!");
            clone();
        } catch (CloneNotSupportedException e) {
            System.out.println("CloneNotSupportedException!");
        }
    }
};

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//CloneNotSupportedException!
//-- join --

int countStackFrames ()

削除予定のため非推奨: このAPI要素は、将来のバージョンで削除される可能性があります。 このメソッドは、最初にスタック・フレーム数をカウントするように設計されていましたが、結果は明確に定義されておらず、スレッド機能に依存していました。

非推奨です。

static Thread currentThread ()

現在実行中のスレッド・オブジェクトの参照を返します。

final Runnable target = () -> {
    final var current = Thread.currentThread();
    System.out.println(current.getName());
};

final var threadA = new Thread(target, "name-A");
final var threadB = new Thread(target, "name-B");
final var threadC = new Thread(target, "name-C");

System.out.println("-- start --");
threadA.start();
threadB.start();
threadC.start();

threadA.join();
threadB.join();
threadC.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//name-A
//name-B
//name-C
//-- join --

static void dumpStack ()

現在のスレッドのスタック・トレースを標準エラー・ストリームに出力します。

final Thread thread = new Thread(() -> {
    Thread.dumpStack();
});

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//java.lang.Exception: Stack trace
//	at java.base/java.lang.Thread.dumpStack(Thread.java:1380)
//	at ThreadTest.lambda$dumpStack$7(ThreadTest.java:638)
//	at java.base/java.lang.Thread.run(Thread.java:833)
//-- join --

static int enumerate (Thread[] tarray)

現行スレッドのスレッド・グループおよびその下位グループ内のすべてのアクティブなスレッドを、指定された配列にコピーします。

final var groupA = new ThreadGroup("group-A");
final var groupB = new ThreadGroup("group-B");
final var baseThreadName = "name-baseA";

final var baseThread = new Thread(groupA, () -> {
    final Runnable target = () -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted!");
        }
    };

    try {
        final var t1 = new Thread(target, "name-A1");
        t1.start();
        final var t2 = new Thread(target, "name-A2");
        t2.start();

        // 別グループ
        final var t3 = new Thread(groupB, target);
        t3.start();

        final var threads = new Thread[Thread.activeCount()];
        System.out.println("threads length : " + threads.length);

        Thread.enumerate(threads);

        for (final var thread : threads) {
            System.out.println("thread : " + thread.getName());
        }

        t1.join();
        t2.join();
        t3.join();

    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    }
}, baseThreadName);

System.out.println("-- start --");
baseThread.start();

baseThread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//threads length : 3
//thread : name-baseA
//thread : name-A1
//thread : name-A2
//-- join --

static Map<Thread,StackTraceElement[]> getAllStackTraces ()

すべてのライブ・スレッドのスタック・トレース・マップを返します。

final var thread = new Thread(() -> {

    final var stackTracesMap = Thread.getAllStackTraces();
    for (final var entry : stackTracesMap.entrySet()) {
        System.out.println("============= entry =============");
        final var key = entry.getKey();
        System.out.println("thread name : " + key.getName());

        for (final var stackTraces : entry.getValue()) {
            System.out.println(stackTraces);
        }
    }
}, "name-A");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//============= entry =============
//thread name : main
//java.base@17.0.1/java.lang.Object.wait(Native Method)
//java.base@17.0.1/java.lang.Thread.join(Thread.java:1304)
//java.base@17.0.1/java.lang.Thread.join(Thread.java:1372)
//Main.main(Main.java:21)
//...
//============= entry =============
//thread name : name-A
//java.base@17.0.1/java.lang.Thread.dumpThreads(Native Method)
//java.base@17.0.1/java.lang.Thread.getAllStackTraces(Thread.java:1662)
//Main.lambda$main$0(Main.java:6)
// ...

ClassLoader getContextClassLoader ()

このスレッドのコンテキストClassLoaderを返します。

final var thread = new Thread(() -> {
    System.out.println("Run!");
});

final var before = thread.getContextClassLoader();
System.out.println(before); // jdk.internal.loader.ClassLoaders$AppClassLoader@4e25154f

final var url = new URL("file:/R:/java-work/classes");
thread.setContextClassLoader(new URLClassLoader(new URL[]{url}));

final var after = thread.getContextClassLoader();
System.out.println(after); // java.net.URLClassLoader@5c7bfdc1

static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler ()

キャッチされない例外によりスレッドが突然終了したときに呼び出されるデフォルトのハンドラを返します。

final var handler = new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("uncaughtException called");
        System.out.println("thread name : " + t.getName());
        System.out.println("throwable : " + e.getMessage());
    }
};

System.out.println("handler : " + Thread.getDefaultUncaughtExceptionHandler());

Thread.setDefaultUncaughtExceptionHandler(handler);

System.out.println("handler : " + (Thread.getDefaultUncaughtExceptionHandler() == handler));

final var thread = new Thread(() -> {
    throw new RuntimeException("Exception!");
}, "name-A");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//handler : null
//handler : true
//-- start --
//uncaughtException called
//thread name : name-A
//throwable : Exception!
//-- join --

long getId ()

このスレッドの識別子を返します。

final var t1 = new Thread(() -> {
    System.out.println("thread 1 : " + Thread.currentThread().getId());
});
final var t2 = new Thread(() -> {
    System.out.println("thread 2 : " + Thread.currentThread().getId());
});
final var t3 = new Thread(() -> {
    System.out.println("thread 3 : " + Thread.currentThread().getId());
});

System.out.println("-- start --");
t1.start();
t2.start();
t3.start();

t1.join();
t2.join();
t3.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//thread 1 : 18
//thread 2 : 19
//thread 3 : 20
//-- join --

final String getName ()

このスレッドの名前を返します。

final var thread = new Thread(() -> {
    System.out.println("thread : " + Thread.currentThread().getName());
}, "name-A");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//thread : name-A
//-- join --
final var thread = new Thread(() -> {
    System.out.println("thread : " + Thread.currentThread().getName());
});

thread.setName("name-B");

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//thread : name-B
//-- join --

final int getPriority ()

このスレッドの優先順位を返します。

final var t1 = new Thread(() -> {
    System.out.println("thread default priority : " + Thread.currentThread().getPriority());
});
final var t2 = new Thread(() -> {
    System.out.println("thread min priority : " + Thread.currentThread().getPriority());
});
final var t3 = new Thread(() -> {
    System.out.println("thread max priority : " + Thread.currentThread().getPriority());
});

t2.setPriority(Thread.MIN_PRIORITY);
t3.setPriority(Thread.MAX_PRIORITY);

System.out.println("-- start --");
t1.start();
t2.start();
t3.start();

t1.join();
t2.join();
t3.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//thread default priority : 5
//thread min priority : 1
//thread max priority : 10
//-- join --

StackTraceElement[] getStackTrace ()

このスレッドのスタック・ダンプを表すスタック・トレース要素の配列を返します。

final var thread = new Thread(() -> {
    final var current = Thread.currentThread();
    for (final var stackTrace : current.getStackTrace()) {
        System.out.println(stackTrace);
    }
});

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//java.base/java.lang.Thread.getStackTrace(Thread.java:1610)
//ThreadTest.lambda$getStackTraces$20(ThreadTest.java:1010)
//java.base/java.lang.Thread.run(Thread.java:833)
//-- join --

Thread.State getState ()

このスレッドの状態を返します。

final var thread = new Thread(() -> {
    final var current = Thread.currentThread();
    System.out.println("state run : " + current.getState());
});

System.out.println("state new : " + thread.getState());

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

System.out.println("state term : " + thread.getState());

// 結果
// ↓
//state new : NEW
//-- start --
//state run : RUNNABLE
//-- join --
//state term : TERMINATED

final ThreadGroup getThreadGroup ()

このスレッドが所属するスレッド・グループを返します。

final var group = new ThreadGroup("group-A");
final var thread = new Thread(group, () -> {
    final var current = Thread.currentThread();
    System.out.println("group : " + current.getThreadGroup());
});

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//group : java.lang.ThreadGroup[name=group-A,maxpri=10]
//-- join --

Thread.UncaughtExceptionHandler getUncaughtExceptionHandler ()

キャッチされない例外によりスレッドが突然終了したときに呼び出されるハンドラを返します。

final var handler = new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("uncaughtException called");
        System.out.println("thread name : " + t.getName());
        System.out.println("throwable : " + e.getMessage());
    }
};

final var thread = new Thread(() -> {
    throw new RuntimeException("Exception!");
}, "name-A");

thread.setUncaughtExceptionHandler(handler);

System.out.println("handler : " + (thread.getUncaughtExceptionHandler() == handler));

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//handler : true
//-- start --
//uncaughtException called
//thread name : name-A
//throwable : Exception!
//-- join --

static boolean holdsLock (Object obj)

現行スレッドが指定されたオブジェクトに対するモニター・ロックを保持する場合にのみ、trueを返します。

final var obj = new Object();
synchronized (obj) {
    System.out.println(Thread.holdsLock(obj)); // true
}

System.out.println(Thread.holdsLock(obj)); // false

void interrupt ()

このスレッドに割り込みます。

final var thread = new Thread(() -> {
    try {
        System.out.println("task start");
        Thread.sleep(1000);

    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task end");
    }
});

System.out.println("-- start --");
thread.start();

thread.interrupt();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//task start
//Interrupted!
//task end
//-- join --

static boolean interrupted ()

現在のスレッドが割り込まれているかどうかを調べします。

このメソッドを呼び出すと、現在の割込みステータスを取得しつつ割込みステータスがクリアされます。
少し直感的ではないかもしれないのでご注意ください。

割込みステータス取得のみを目的とする場合は isInterrupted() をご使用ください。

final var thread = new Thread(() -> {
    try {
        System.out.println("task start");

        System.out.println("before : " + Thread.interrupted());

        while (!Thread.interrupted()) {
            Thread.onSpinWait();
        }

        System.out.println("after : " + Thread.interrupted());

    } finally {
        System.out.println("task end");
    }
});

System.out.println("-- start --");
thread.start();

Thread.sleep(100);

thread.interrupt();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//task start
//before : false
//after : false
//task end
//-- join --

final boolean isAlive ()

このスレッドが生存しているかどうかを判定します。

final var thread = new Thread(() -> {
    try {
        System.out.println("task start");
        Thread.sleep(1000);

    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task end");
    }
});

System.out.println("isAlive : " + thread.isAlive());

System.out.println("-- start --");
thread.start();

System.out.println("isAlive : " + thread.isAlive());

thread.join();
System.out.println("-- join --");

System.out.println("isAlive : " + thread.isAlive());

// 結果
// ↓
//isAlive : false
//-- start --
//task start
//isAlive : true
//task end
//-- join --
//isAlive : false

final boolean isDaemon ()

このスレッドがデーモン・スレッドであるかどうかを判定します。

final var daemonThread = new Thread(() -> {
    try {
        System.out.println("task start");
        Thread.sleep(1000);

    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task end");
    }
});

daemonThread.setDaemon(true);

System.out.println("-- start --");
daemonThread.start();

Thread.sleep(100);
System.out.println("isDaemon : " + daemonThread.isDaemon());

daemonThread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//task start
//isDaemon : true
//task end
//-- join --

boolean isInterrupted ()

このスレッドが割り込まれているどうかを調べます。

関連:interrupted()

final var thread = new Thread(() -> {
    try {
        System.out.println("task start");

        System.out.println("before : " + Thread.interrupted());

        final var current = Thread.currentThread();
        while (!current.isInterrupted()) {
            Thread.onSpinWait();
        }

        System.out.println("after : " + Thread.interrupted());

    } finally {
        System.out.println("task end");
    }

});

System.out.println("-- start --");
thread.start();

Thread.sleep(100);

thread.interrupt();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//task start
//before : false
//after : true
//task end
//-- join --

final void join ()

このスレッドが終了するのを待機します。

final var thread = new Thread(() -> {
    try {
        System.out.println("task : start");
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task : end");
    }
});

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//task : start
//task : end
//-- join --

// ※joinはただ待つだけで、スレッドの割込みは行いません。

final void join (long millis)

このスレッドが終了するのを、最高でmillisミリ秒待機します。

final var thread = new Thread(() -> {
    try {
        System.out.println("task : start");
        Thread.sleep(3 * 1000);
    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task : end");
    }
});

System.out.println("-- start --");
thread.start();

thread.join(2 * 1000);
System.out.println("-- join --");

Thread.sleep(5 * 1000);
System.out.println("-- sleep --");

// 結果
// ↓
//-- start --
//task : start
//-- join --
//task : end
//-- sleep --

// ※joinはただ待つだけで、スレッドの割込みは行いません。

final void join (long millis, int nanos)

最高でmillisミリ秒にnanosナノ秒を加算した間、このスレッドが終了するのを待機します。

final var thread = new Thread(() -> {
    try {
        System.out.println("task : start");
        Thread.sleep(3 * 1000);
    } catch (InterruptedException e) {
        System.out.println("Interrupted!");
    } finally {
        System.out.println("task : end");
    }
});

System.out.println("-- start --");
thread.start();

thread.join(2 * 1000, 1234);
System.out.println("-- join --");

Thread.sleep(5 * 1000);
System.out.println("-- sleep --");

// 結果
// ↓
//-- start --
//task : start
//-- join --
//task : end
//-- sleep --

// ※joinはただ待つだけで、スレッドの割込みは行いません。

static void onSpinWait ()

他のアクティビティの一部で1つ以上のアクションが発生するまで、発信者が瞬間的に進行できないことを示します。

このメソッドの使用例は、interrupted() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

final void resume ()

削除予定のため非推奨: このAPI要素は、将来のバージョンで削除される可能性があります。 このメソッドはsuspend()とともに使用するためにのみ存在しますが、これはデッドロックを発生させやすいため推奨されていません。

非推奨です。

void run ()

このスレッドが別個のRunnable実行オブジェクトを使用して作成された場合、そのRunnableオブジェクトのrunメソッドが呼び出されます。それ以外の場合、このメソッドは何も行わずに復帰します。

final var thread = new Thread() {
    @Override
    public void run() {
        System.out.println("Run!");
    }
};

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//-- join --

void setContextClassLoader (ClassLoader cl)

このThreadのコンテキストClassLoaderを設定します。

このメソッドの使用例は、getContextClassLoader() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

final void setDaemon (boolean on)

このスレッドを、デーモン・スレッドまたはユーザー・スレッドとしてマークします。

このメソッドの使用例は、isDaemon() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

static void setDefaultUncaughtExceptionHandler (Thread.UncaughtExceptionHandler eh)

キャッチされない例外により、スレッドが突然終了したときや、このスレッドに対してほかにハンドラが定義されていないときに呼び出されるデフォルトのハンドラを設定します。

このメソッドの使用例は、getDefaultUncaughtExceptionHandler() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

final void setName (String name)

このスレッドの名前を引数nameに等しくなるように変更します。

このメソッドの使用例は、getName() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

final void setPriority (int newPriority)

このスレッドの優先順位を変更します。

このメソッドの使用例は、getPriority() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

void setUncaughtExceptionHandler (Thread.UncaughtExceptionHandler eh)

キャッチされない例外により、突然スレッドが終了したときに使用されるハンドラを設定します。

このメソッドの使用例は、getUncaughtExceptionHandler() にまとめて記載しました。
そちらのAPI使用例をご参照ください。

static void sleep (long millis)

システム・タイマーとスケジューラが正確であることを前提として、現在実行中のスレッドを、指定されたミリ秒数の間、スリープ(一時的に実行を停止)させます。

final var start = System.nanoTime();

// 1秒スリープ
Thread.sleep(1000);

final var sec = (System.nanoTime() - start) / 1000000000.0;
System.out.println(sec); // 1.0088005

static void sleep (long millis, int nanos)

システム・タイマーとスケジューラが正確であることを前提として、現在実行中のスレッドを、指定されたミリ秒数に指定されたナノ秒数を加算した間、スリープ(一時的に実行を停止)させます。

final var start = System.nanoTime();

Thread.sleep(1000, 999999);

final var sec = (System.nanoTime() - start) / 1000000000.0;
System.out.println(sec); // 1.0012892

// ※実行環境によってナノ秒の精度は変わりそうです。

void start ()

このスレッドの実行を開始します。Java仮想マシンは、このスレッドのrunメソッドを呼び出します。

final var thread = new Thread(() -> System.out.println("Run!"));

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//-- start --
//Run!
//-- join --

final void stop ()

非推奨。 このメソッドは本質的に安全ではありません。

非推奨です。

final void suspend ()

削除予定のため非推奨: このAPI要素は、将来のバージョンで削除される可能性があります。 このメソッドはデッドロックを発生しやすいため非推奨です。

非推奨です。

String toString ()

スレッドの名前、優先順位、スレッド・グループを含むこのスレッドの文字列表現を返します。

final var thread = new Thread(new ThreadGroup("group-A"),
        () -> System.out.println("Run!"), "name-A");

thread.setPriority(7);

final var str = thread.toString();
System.out.println(str);

System.out.println("-- start --");
thread.start();

thread.join();
System.out.println("-- join --");

// 結果
// ↓
//Thread[name-A,7,group-A]
//-- start --
//Run!
//-- join --

static void yield ()

現在のスレッドが現在のプロセッサ使用量を譲る用意があることを示す、スケジューラへのヒントです。
...
このメソッドを使用する機会はまれにしかありません。

API仕様に"通常ケースではほぼ使われない"とあるのでコード例は省略します。
(呼び出したことによる効果が確認しづらい、ということもあり…)


関連記事

ページの先頭へ