1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("Main");
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        System.out.println("Main");
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13public class Main {
    public static void main(String[] args) {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("myThread");
            }
        });
        myThread.start();
        System.out.println("Main");
    }
}

1
2
3
4
5
6
7
8
9
10public class Main {
    public static void main(String[] args) {
        Thread myThread = new Thread(() -> {
            System.out.println("myThread");
        });
        myThread.start();
        System.out.println("Main");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class ThreadTerminationExample1 {
    private static volatile boolean isRunning = true; // 自定义标识符

    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(() -> {
            while (isRunning) {
                // 线程执行的代码
            }
            System.out.println("Thread terminated.");
        });
        myThread.start();

        // 模拟一段时间后停止线程
        Thread.sleep(1000);
        isRunning = false; // 设置标识符来终止线程
    }
}

1
2
3
4while (!Thread.currentThread().isInterrupted()) {
    // 线程执行的代码
}

1
2
3
4
5
6
7
8
9try {
    // 在等待期间可能抛出InterruptedException
    // 处理等待逻辑
} catch (InterruptedException e) {
    e.printStackTrace();
    // 重新设置中断状态
    Thread.currentThread().interrupt();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23public class ThreadInterruptExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000); // 模拟线程工作
                } catch (InterruptedException e) {
                    System.out.println("线程收到中断请求");
                    Thread.currentThread().interrupt(); // 重新设置中断状态
                }
            }
            System.out.println("线程结束");
        });
        t.start();

        // 模拟一段时间后停止线程
        Thread.sleep(5000);
        System.out.println("t线程终止");
        t.interrupt();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12public class ThreadJoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("线程运行中.");
        });
        thread.start();
        // 等待线程执行完毕
        thread.join();
        System.out.println("主方法运行中.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class ThreadSleepExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            long begin = System.currentTimeMillis();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println(end - begin);
        });
        t.start();
    }
}

5000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import java.util.concurrent.TimeUnit;

public class ThreadTimeUnitExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            long begin = System.currentTimeMillis();
            try {
                TimeUnit.MICROSECONDS.sleep(1000); // 休眠1微秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println(end - begin);
        });
        t.start();
    }
}

1
2
3
4
5
6
7public class ThreadInstanceExample {
    public static void main(String[] args) {
        Thread currentThread = Thread.currentThread();
        System.out.println("Current thread: " + currentThread.getName());
    }
}