Java 多线程 学习总结（附代码示例）🐳

1
public class MyThreadDemo {
2
    public static void main(String[] args) {
3
        // 3. 创建 Thread 子类的对象
4
        MyThread my1 = new MyThread();
5
        MyThread my2 = new MyThread();
6

7
        // 千万别用对象直接调 run()：那只是普通方法调用，并没有开启新线程！
8
        // my1.run();
9
        // my2.run();
10

11
        // 4. 用 start() 启动线程，JVM 会自动调用 run()
12
        my1.start(); // start() 才是真正开启新线程
13
        my2.start();
14
    }
15
}

1
public class MyRunnableDemo {
2
    public static void main(String[] args) {
3
        // 3. 创建 Runnable 实现类对象（一份任务）
4
        MyRunnable my = new MyRunnable();
5

6
        // 4. Thread(Runnable target)：把任务放进 Thread 里
7
        Thread t1 = new Thread(my);
8
        Thread t2 = new Thread(my);
9

10
        // 4. Thread(Runnable target, String name)：放任务 + 起名字
11
        Thread t3 = new Thread(my, "丛雨");
12
        Thread t4 = new Thread(my, "芳乃");
13

14
        // 5. 启动线程
15
        t1.start();
16
        t2.start();
17
        t3.start();
18
        t4.start();
19
    }
20
}

1
public class Demo {
2
    public static void main(String[] args) throws ExecutionException, InterruptedException {
3
        // 3. 创建 Callable 实现类对象
4
        MyCallable mc = new MyCallable();
5

6
        // Thread 的构造参数只能接收 Runnable 的实现类对象，
7
        // 所以不能直接把 mc 塞给 Thread：
8
        // Thread t1 = new Thread(mc);   // ✗ 编译不过
9

10
        // 4. 借助 FutureTask：它既能装 Callable，本身又实现了 Runnable
11
        FutureTask<String> ft = new FutureTask<>(mc);
12

13
        // 5. 创建线程对象，把 FutureTask 传进去
14
        Thread t1 = new Thread(ft);
15

16
        // 6. 先启动线程，任务才会真正执行
17
        t1.start();
18

19
        // 7. get() 会阻塞等待线程执行完，再取出结果
20
        String s1 = ft.get(); // 阻塞等待执行结果
21
        System.out.println(s1);
22

23
        // 再取一次：FutureTask 的结果只会计算一次，多次 get 拿到的是同一个值
24
        String s2 = ft.get();
25
        System.out.println(s2);
26
    }
27
}

1
// 继承 Thread，并提供一个带名字的构造方法
2
public class MyThread extends Thread {
3
    public MyThread() {}
4

5
    public MyThread(String name) {
6
        super(name); // 把名字交给父类处理
7
    }
8

9
    @Override
10
    public void run() {
11
        for (int i = 0; i < 100; i++) {
12
            System.out.println(getName() + " : " + i);
13
        }
14
    }
15
}

1
public class MyThreadDemo {
2
    public static void main(String[] args) {
3
        // 方式一：创建之后再用 setName() 起名
4
        MyThread my1 = new MyThread();
5
        MyThread my2 = new MyThread();
6
        my1.setName("丛雨");
7
        my2.setName("芳乃");
8

9
        // 方式二：创建时直接用带参构造起名（二选一即可，这里都演示一遍）
10
        MyThread my3 = new MyThread("丛雨二号");
11
        MyThread my4 = new MyThread("芳乃二号");
12

13
        my1.start();
14
        my2.start();
15
        my3.start();
16
        my4.start();
17

18
        // static Thread currentThread()：返回当前正在执行这段代码的线程
19
        System.out.println(Thread.currentThread().getName());
20
    }
21
}

1
// 实现 Runnable 接口
2
public class MyRunnable implements Runnable {
3
    @Override
4
    public void run() {
5
        for (int i = 0; i < 100; i++) {
6
            // 每打印一次就让线程睡 100 毫秒，模拟耗时任务
7
            try {
8
                Thread.sleep(100);
9
            } catch (InterruptedException e) {
10
                e.printStackTrace();
11
            }
12
            System.out.println(Thread.currentThread().getName() + " --- " + i);
13
        }
14
    }
15
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        // 优先级：1 ~ 10，默认值 5
4
        MyCallable mc = new MyCallable();
5
        FutureTask<String> ft = new FutureTask<>(mc);
6

7
        Thread t1 = new Thread(ft);
8
        t1.setName("丛雨");
9
        t1.setPriority(10); // 把 t1 的优先级调到最高 10
10
        t1.start();
11

12
        MyCallable mc2 = new MyCallable();
13
        FutureTask<String> ft2 = new FutureTask<>(mc2);
14

15
        Thread t2 = new Thread(ft2);
16
        t2.setName("芳乃");
17
        t2.setPriority(1); // 把 t2 的优先级调到最低 1
18
        t2.start();
19
    }
20
}

1
public class MyThread1 extends Thread {
2
    @Override
3
    public void run() {
4
        for (int i = 0; i < 10; i++) {
5
            System.out.println(getName() + " --- " + i);
6
        }
7
    }
8
}
9

10
public class MyThread2 extends Thread {
11
    @Override
12
    public void run() {
13
        for (int i = 0; i < 100; i++) {
14
            System.out.println(getName() + " --- " + i);
15
        }
16
    }
17
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        MyThread1 t1 = new MyThread1();
4
        MyThread2 t2 = new MyThread2();
5

6
        t1.setName("女神");
7
        t2.setName("备胎");
8

9
        // 把第二个线程设为守护线程：女神（普通线程）跑完，备胎（守护线程）也没必要继续了
10
        t2.setDaemon(true);
11

12
        t1.start();
13
        t2.start();
14
    }
15
}

1
public class SellTicket implements Runnable {
2
    private int tickets = 100;
3
    private Object obj = new Object(); // 锁对象：多个线程必须共用这一把锁
4

5
    @Override
6
    public void run() {
7
        while (true) {
8
            synchronized (obj) { // 把可能有安全问题的代码锁起来
9
                // t1 进来后，这段代码就被锁住了
10
                if (tickets > 0) {
11
                    try {
12
                        Thread.sleep(100); // 模拟出票耗时，放大线程安全问题
13
                    } catch (InterruptedException e) {
14
                        e.printStackTrace();
15
                    }
16
                    System.out.println(Thread.currentThread().getName()
17
                            + "正在出售第" + tickets + "张票");
18
                    tickets--;
19
                }
20
            }
21
            // t1 出来，锁就被释放，其他线程才能进来
22
        }
23
    }
24
}

1
public class MyRunnable implements Runnable {
2
    private static int ticketCount = 100; // 共享数据：静态变量，全局只有一份
3

4
    @Override
5
    public void run() {
6
        while (true) {
7
            // 窗口一：走同步方法
8
            if ("窗口一".equals(Thread.currentThread().getName())) {
9
                boolean result = synchronizedMethod();
10
                if (result) {
11
                    break; // 票卖完了，结束循环
12
                }
13
            }
14

15
            // 窗口二：走同步代码块，锁用 类名.class（和静态同步方法同一把锁）
16
            if ("窗口二".equals(Thread.currentThread().getName())) {
17
                synchronized (MyRunnable.class) {
18
                    if (ticketCount == 0) {
19
                        break;
20
                    } else {
21
                        try {
22
                            Thread.sleep(10);
23
                        } catch (InterruptedException e) {
24
                            e.printStackTrace();
25
                        }
26
                        ticketCount--;
27
                        System.out.println(Thread.currentThread().getName()
28
                                + "在卖票，还剩下" + ticketCount + "张票");
29
                    }
30
                }
31
            }
32
        }
33
    }
34

35
    // 静态同步方法：锁对象是 MyRunnable.class
36
    private static synchronized boolean synchronizedMethod() {
37
        if (ticketCount == 0) {
38
            return true;
39
        } else {
40
            try {
41
                Thread.sleep(10);
42
            } catch (InterruptedException e) {
43
                e.printStackTrace();
44
            }
45
            ticketCount--;
46
            System.out.println(Thread.currentThread().getName()
47
                    + "在卖票，还剩下" + ticketCount + "张票");
48
            return false;
49
        }
50
    }
51
}

1
public class Ticket implements Runnable {
2
    private int ticket = 100; // 票的数量
3
    private ReentrantLock lock = new ReentrantLock(); // 创建 Lock 锁对象
4

5
    @Override
6
    public void run() {
7
        while (true) {
8
            // synchronized (obj) { // 也可以像这样用同步代码块，但这里演示 Lock
9
            try {
10
                lock.lock(); // 手动加锁
11
                if (ticket <= 0) {
12
                    break; // 卖完了，退出
13
                } else {
14
                    Thread.sleep(100);
15
                    ticket--;
16
                    System.out.println(Thread.currentThread().getName()
17
                            + "在卖票，还剩下" + ticket + "张票");
18
                }
19
            } catch (InterruptedException e) {
20
                e.printStackTrace();
21
            } finally {
22
                lock.unlock(); // 释放锁（finally 保证一定会执行）
23
            }
24
            // }
25
        }
26
    }
27
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        Ticket ticket = new Ticket();
4

5
        Thread t1 = new Thread(ticket);
6
        Thread t2 = new Thread(ticket);
7
        Thread t3 = new Thread(ticket);
8
        t1.setName("窗口一");
9
        t2.setName("窗口二");
10
        t3.setName("窗口三");
11

12
        t1.start();
13
        t2.start();
14
        t3.start();
15
    }
16
}

1
public class MyThread extends Thread {
2

3
    // 两把共享的锁对象（static 保证全局只有一份）
4
    static Object objA = new Object();
5
    static Object objB = new Object();
6

7
    @Override
8
    public void run() {
9
        while (true) {
10
            if ("线程A".equals(getName())) {
11
                synchronized (objA) { // A 先拿 A 锁
12
                    System.out.println("线程A拿到了A锁，准备拿B锁");
13
                    synchronized (objB) { // A 再拿 B 锁
14
                        System.out.println("线程A拿到了B锁，顺利执行完一轮");
15
                    }
16
                }
17
            } else if ("线程B".equals(getName())) {
18
                synchronized (objB) { // B 先拿 B 锁
19
                    System.out.println("线程B拿到了B锁，准备拿A锁");
20
                    synchronized (objA) { // B 再拿 A 锁
21
                        System.out.println("线程B拿到了A锁，顺利执行完一轮");
22
                    }
23
                }
24
            }
25
        }
26
    }
27
}

1
public class MyThreadPoolDemo {
2
    public static void main(String[] args) {
3
        /*
4
            Executors.newCachedThreadPool()              创建一个没有上限的线程池
5
            Executors.newFixedThreadPool(int nThreads)   创建一个有上限的线程池
6
        */
7

8
        // 1. 获取线程池对象（固定 3 个线程）
9
        ExecutorService pool1 = Executors.newFixedThreadPool(3);
10

11
        // 2. 提交 6 个任务：3 个线程会轮流复用，而不是创建 6 个新线程
12
        pool1.submit(new MyRunnable());
13
        pool1.submit(new MyRunnable());
14
        pool1.submit(new MyRunnable());
15
        pool1.submit(new MyRunnable());
16
        pool1.submit(new MyRunnable());
17
        pool1.submit(new MyRunnable());
18

19
        // 3. 销毁线程池（一般不会用）
20
        // 想想看：一个游戏服务器的 CPU 正常情况下会随便关闭吗？
21
        pool1.shutdown();
22
    }
23
}