Java 线程基础

1
public class DownloadThread extends Thread {
2
    private final String url;
3

4
    public DownloadThread(String url) {
5
        this.url = url;
6
    }
7

8
    @Override
9
    public void run() {
10
        System.out.println(Thread.currentThread().getName() + " 下载: " + url);
11
        // 模拟下载
12
    }
13
}
14

15
// 使用
16
public class Demo1 {
17
    public static void main(String[] args) {
18
        Thread t = new DownloadThread("https://example.com/a.zip");
19
        t.setName("download-1");
20
        t.start(); // 必须 start，不能只 run()
21
    }
22
}

1
public class DownloadTask implements Runnable {
2
    private final String url;
3

4
    public DownloadTask(String url) {
5
        this.url = url;
6
    }
7

8
    @Override
9
    public void run() {
10
        System.out.println(Thread.currentThread().getName() + " 下载: " + url);
11
    }
12
}
13

14
public class Demo2 {
15
    public static void main(String[] args) {
16
        Runnable task = new DownloadTask("https://example.com/b.zip");
17
        // 等价：Runnable task = () -> System.out.println("lambda 任务");
18

19
        Thread t = new Thread(task, "download-2");
20
        t.start();
21
    }
22
}

1
import java.util.concurrent.Callable;
2
import java.util.concurrent.ExecutionException;
3
import java.util.concurrent.FutureTask;
4

5
public class SumTask implements Callable<Integer> {
6
    private final int from, to;
7

8
    public SumTask(int from, int to) {
9
        this.from = from;
10
        this.to = to;
11
    }
12

13
    @Override
14
    public Integer call() throws Exception {
15
        int sum = 0;
16
        for (int i = from; i <= to; i++) {
17
            sum += i;
18
        }
19
        return sum; // 有返回值
20
    }
21
}
22

23
public class Demo3 {
24
    public static void main(String[] args) throws ExecutionException, InterruptedException {
25
        Callable<Integer> callable = new SumTask(1, 100);
26

27
        // FutureTask 既是 Future（拿结果），又是 Runnable（能交给 Thread）
28
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
29

30
        Thread t = new Thread(futureTask, "sum-worker");
31
        t.start();
32

33
        // 主线程继续干别的，需要结果时再 get（会阻塞直到算完）
34
        System.out.println("主线程先做别的...");
35
        Integer result = futureTask.get();
36
        System.out.println("1+2+...+100 = " + result);
37
    }
38
}

1
import java.util.concurrent.*;
2

3
public class Demo4 {
4
    public static void main(String[] args) throws Exception {
5
        // 固定 4 个工作线程的池子
6
        ExecutorService pool = Executors.newFixedThreadPool(4);
7

8
        // 4-1：无返回值 —— execute(Runnable)，等价于方式二
9
        pool.execute(() -> System.out.println("execute: " + Thread.currentThread().getName()));
10

11
        // 4-2：有返回值 —— submit(Callable)，等价于方式三
12
        Future<Integer> future = pool.submit(() -> {
13
            Thread.sleep(500);
14
            return 42;
15
        });
16
        System.out.println("submit 结果: " + future.get());
17

18
        pool.shutdown(); // 不再接新任务，已有任务跑完后关闭
19
    }
20
}