Java 入门教程（十一）：多线程与 Lambda

1
// 法1：继承 Thread
2
class Downloader extends Thread {
3
    private final String file;
4
    Downloader(String file) { this.file = file; }
5

6
    @Override
7
    public void run() {                     // 线程要做的事
8
        System.out.println("下载 " + file + " 开始");
9
        try { Thread.sleep(1000); }         // 模拟耗时
10
        catch (InterruptedException e) { return; }
11
        System.out.println("下载 " + file + " 完成");
12
    }
13
}
14

15
// 法2：实现 Runnable（推荐——不占用继承名额）
16
class Task implements Runnable {
17
    @Override
18
    public void run() {
19
        System.out.println("任务运行在: " + Thread.currentThread().getName());
20
    }
21
}
22

23
public class ThreadDemo {
24
    public static void main(String[] args) throws InterruptedException {
25
        Thread t1 = new Downloader("a.zip");
26
        Thread t2 = new Thread(new Task(), "工作线程-2");   // 第二参命名
27
        Thread t3 = new Thread(() -> System.out.println("Lambda 更简洁"),
28
                                "工作线程-3");
29

30
        t1.start();      // ⚠ 调 start() 不是 run()！run() 只是普通方法调用
31
        t2.start();
32
        t3.start();
33

34
        t1.join();       // main 线程等 t1 干完再往下走
35
        System.out.println("main 继续");
36
    }
37
}

1
class SafeCounter {
2
    private int count = 0;
3

4
    public synchronized void increment() {   // 同一时刻只有一个线程能进入
5
        count++;
6
    }
7
    public synchronized int get() { return count; }
8
}
9

10
// 同步块版（锁更小范围）
11
class Pair {
12
    private int a = 0;
13
    public void add() {
14
        synchronized (this) {                // 锁住当前实例
15
            a++;
16
        }
17
    }
18
}

1
import java.util.concurrent.*;
2

3
public class ProducerConsumer {
4
    public static void main(String[] args) throws Exception {
5
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);  // 容量5
6

7
        // 生产者：往队列放（满了自动阻塞等待）
8
        Thread producer = new Thread(() -> {
9
            try {
10
                for (int i = 1; i <= 10; i++) {
11
                    queue.put(i);
12
                    System.out.println("生产 " + i);
13
                }
14
                queue.put(-1);                       // 结束信号
15
            } catch (InterruptedException ignored) {}
16
        });
17

18
        // 消费者：从队列取（空了自动阻塞等待）
19
        Thread consumer = new Thread(() -> {
20
            try {
21
                int v;
22
                while ((v = queue.take()) != -1)
23
                    System.out.println("  消费 " + v);
24
            } catch (InterruptedException ignored) {}
25
        });
26

27
        producer.start();
28
        consumer.start();
29
        producer.join();
30
        consumer.join();
31
    }
32
}

1
// Function<T,R>：T → R（转换）
2
Function<String, Integer> parse = Integer::parseInt;
3
System.out.println(parse.apply("42"));
4

5
// Predicate<T>：T → boolean（判断）
6
Predicate<String> isEmpty = String::isEmpty;
7
System.out.println(isEmpty.test(""));        // true
8

9
// Consumer<T>：T → void（消费）
10
Consumer<String> printer = s -> System.out.println("⚡ " + s);
11
printer.accept("hello");
12

13
// Supplier<T>：() → T（生产/惰性）
14
Supplier<Double> random = Math::random;
15
System.out.println(random.get());