第14章 多线程#

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) {
4
        Thread t = new Thread();
5
        t.start(); // 启动新线程
6
    }
7
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) {
4
        Thread t = new MyThread();
5
        t.start(); // 启动新线程
6
    }
7
}
8

9
class MyThread extends Thread {
10
    @Override
11
    public void run() {
12
        System.out.println("start new thread!");
13
    }
14
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) {
4
        Thread t = new Thread(new MyRunnable());
5
        t.start(); // 启动新线程
6
    }
7
}
8

9
class MyRunnable implements Runnable {
10
    @Override
11
    public void run() {
12
        System.out.println("start new thread!");
13
    }
14
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) {
4
        Thread t = new Thread(() -> {
5
            System.out.println("start new thread!");
6
        });
7
        t.start(); // 启动新线程
8
    }
9
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) {
4
        System.out.println("main start...");
5
        Thread t = new Thread() {
6
            public void run() {
7
                System.out.println("thread run...");
8
                try {
9
                    Thread.sleep(10);
10
                } catch (InterruptedException e) {}
11
                System.out.println("thread end.");
12
            }
13
        };
14
        t.start();
15
        try {
16
            Thread.sleep(20);
17
        } catch (InterruptedException e) {}
18
        System.out.println("main end...");
19
    }
20
}

1
public class Main {
2
    public static void main(String[] args) {
3
        Thread t = new MyThread();
4
        t.run();
5
    }
6
}
7

8
class MyThread extends Thread {
9
    public void run() {
10
        System.out.println("hello");
11
    }
12
}

1
         ┌─────────────┐
2
         │     New     │
3
         └─────────────┘
4
                │
5
                ▼
6
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
7
 ┌─────────────┐ ┌─────────────┐
8
││  Runnable   │ │   Blocked   ││
9
 └─────────────┘ └─────────────┘
10
│┌─────────────┐ ┌─────────────┐│
11
 │   Waiting   │ │Timed Waiting│
12
│└─────────────┘ └─────────────┘│
13
 ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
14
                │
15
                ▼
16
         ┌─────────────┐
17
         │ Terminated  │
18
         └─────────────┘

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) throws InterruptedException {
4
        Thread t = new Thread(() -> {
5
            System.out.println("hello");
6
        });
7
        System.out.println("start");
8
        t.start(); // 启动t线程
9
        t.join(); // 此处main线程会等待t结束
10
        System.out.println("end");
11
    }
12
}

1
// 中断线程
2
public class Main {
3
    public static void main(String[] args) throws InterruptedException {
4
        Thread t = new MyThread();
5
        t.start();
6
        Thread.sleep(1); // 暂停1毫秒
7
        t.interrupt(); // 中断t线程
8
        t.join(); // 等待t线程结束
9
        System.out.println("end");
10
    }
11
}
12

13
class MyThread extends Thread {
14
    public void run() {
15
        int n = 0;
16
        while (! isInterrupted()) {
17
            n ++;
18
            System.out.println(n + " hello!");
19
        }
20
    }
21
}

1
// 中断线程
2
public class Main {
3
    public static void main(String[] args) throws InterruptedException {
4
        Thread t = new MyThread();
5
        t.start();
6
        Thread.sleep(1000);
7
        t.interrupt(); // 中断t线程
8
        t.join(); // 等待t线程结束
9
        System.out.println("end");
10
    }
11
}
12

13
class MyThread extends Thread {
14
    public void run() {
15
        Thread hello = new HelloThread();
16
        hello.start(); // 启动hello线程
17
        try {
18
            hello.join(); // 等待hello线程结束
19
        } catch (InterruptedException e) {
20
            System.out.println("interrupted!");
21
        }
22
        hello.interrupt();
23
    }
24
}
25

26
class HelloThread extends Thread {
27
    public void run() {
28
        int n = 0;
29
        while (!isInterrupted()) {
30
            n++;
31
            System.out.println(n + " hello!");
32
            try {
33
                Thread.sleep(100);
34
            } catch (InterruptedException e) {
35
                break;
36
            }
37
        }
38
    }
39
}

1
// 中断线程
2
public class Main {
3
    public static void main(String[] args)  throws InterruptedException {
4
        HelloThread t = new HelloThread();
5
        t.start();
6
        Thread.sleep(1);
7
        t.running = false; // 标志位置为false
8
    }
9
}
10

11
class HelloThread extends Thread {
12
    public volatile boolean running = true;
13
    public void run() {
14
        int n = 0;
15
        while (running) {
16
            n ++;
17
            System.out.println(n + " hello!");
18
        }
19
        System.out.println("end!");
20
    }
21
}

1
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
2
           Main Memory
3
│                               │
4
   ┌───────┐┌───────┐┌───────┐
5
│  │ var A ││ var B ││ var C │  │
6
   └───────┘└───────┘└───────┘
7
│     │ ▲               │ ▲     │
8
 ─ ─ ─│─│─ ─ ─ ─ ─ ─ ─ ─│─│─ ─ ─
9
      │ │               │ │
10
┌ ─ ─ ┼ ┼ ─ ─ ┐   ┌ ─ ─ ┼ ┼ ─ ─ ┐
11
      ▼ │               ▼ │
12
│  ┌───────┐  │   │  ┌───────┐  │
13
   │ var A │         │ var C │
14
│  └───────┘  │   │  └───────┘  │
15
   Thread 1          Thread 2
16
└ ─ ─ ─ ─ ─ ─ ┘   └ ─ ─ ─ ─ ─ ─ ┘

1
class TimerThread extends Thread {
2
    @Override
3
    public void run() {
4
        while (true) {
5
            System.out.println(LocalTime.now());
6
            try {
7
                Thread.sleep(1000);
8
            } catch (InterruptedException e) {
9
                break;
10
            }
11
        }
12
    }
13
}

1
Thread t = new MyThread();
2
t.setDaemon(true);
3
t.start();

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) throws Exception {
4
        var add = new AddThread();
5
        var dec = new DecThread();
6
        add.start();
7
        dec.start();
8
        add.join();
9
        dec.join();
10
        System.out.println(Counter.count);
11
    }
12
}
13

14
class Counter {
15
    public static int count = 0;
16
}
17

18
class AddThread extends Thread {
19
    public void run() {
20
        for (int i=0; i<10000; i++) { Counter.count += 1; }
21
    }
22
}
23

24
class DecThread extends Thread {
25
    public void run() {
26
        for (int i=0; i<10000; i++) { Counter.count -= 1; }
27
    }
28
}

1
n = n + 1;

1
ILOAD
2
IADD
3
ISTORE

1
┌───────┐     ┌───────┐
2
│Thread1│     │Thread2│
3
└───┬───┘     └───┬───┘
4
    │             │
5
    │ILOAD (100)  │
6
    │             │ILOAD (100)
7
    │             │IADD
8
    │             │ISTORE (101)
9
    │IADD         │
10
    │ISTORE (101) │
11
    ▼             ▼

1
┌───────┐     ┌───────┐
2
│Thread1│     │Thread2│
3
└───┬───┘     └───┬───┘
4
    │             │
5
    │-- lock --   │
6
    │ILOAD (100)  │
7
    │IADD         │
8
    │ISTORE (101) │
9
    │-- unlock -- │
10
    │             │-- lock --
11
    │             │ILOAD (101)
12
    │             │IADD
13
    │             │ISTORE (102)
14
    │             │-- unlock --
15
    ▼             ▼

1
synchronized(lock) {
2
    n = n + 1;
3
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) throws Exception {
4
        var add = new AddThread();
5
        var dec = new DecThread();
6
        add.start();
7
        dec.start();
8
        add.join();
9
        dec.join();
10
        System.out.println(Counter.count);
11
    }
12
}
13

14
class Counter {
15
    public static final Object lock = new Object();
16
    public static int count = 0;
17
}
18

19
class AddThread extends Thread {
20
    public void run() {
21
        for (int i=0; i<10000; i++) {
22
            synchronized(Counter.lock) {
23
                Counter.count += 1;
24
            }
25
        }
26
    }
27
}
28

29
class DecThread extends Thread {
30
    public void run() {
31
        for (int i=0; i<10000; i++) {
32
            synchronized(Counter.lock) {
33
                Counter.count -= 1;
34
            }
35
        }
36
    }
37
}

1
synchronized(Counter.lock) { // 获取锁
2
    ...
3
} // 释放锁

1
public void add(int m) {
2
    synchronized (obj) {
3
        if (m < 0) {
4
            throw new RuntimeException();
5
        }
6
        this.value += m;
7
    } // 无论有无异常，都会在此释放锁
8
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) throws Exception {
4
        var add = new AddThread();
5
        var dec = new DecThread();
6
        add.start();
7
        dec.start();
8
        add.join();
9
        dec.join();
10
        System.out.println(Counter.count);
11
    }
12
}
13

14
class Counter {
15
    public static final Object lock1 = new Object();
16
    public static final Object lock2 = new Object();
17
    public static int count = 0;
18
}
19

20
class AddThread extends Thread {
21
    public void run() {
22
        for (int i=0; i<10000; i++) {
23
            synchronized(Counter.lock1) {
24
                Counter.count += 1;
25
            }
26
        }
27
    }
28
}
29

30
class DecThread extends Thread {
31
    public void run() {
32
        for (int i=0; i<10000; i++) {
33
            synchronized(Counter.lock2) {
34
                Counter.count -= 1;
35
            }
36
        }
37
    }
38
}

1
// 多线程
2
public class Main {
3
    public static void main(String[] args) throws Exception {
4
        var ts = new Thread[] { new AddStudentThread(), new DecStudentThread(), new AddTeacherThread(), new DecTeacherThread() };
5
        for (var t : ts) {
6
            t.start();
7
        }
8
        for (var t : ts) {
9
            t.join();
10
        }
11
        System.out.println(Counter.studentCount);
12
        System.out.println(Counter.teacherCount);
13
    }
14
}
15

16
class Counter {
17
    public static final Object lock = new Object();
18
    public static int studentCount = 0;
19
    public static int teacherCount = 0;
20
}
21

22
class AddStudentThread extends Thread {
23
    public void run() {
24
        for (int i=0; i<10000; i++) {
25
            synchronized(Counter.lock) {
26
                Counter.studentCount += 1;
27
            }
28
        }
29
    }
30
}
31

32
class DecStudentThread extends Thread {
33
    public void run() {
34
        for (int i=0; i<10000; i++) {
35
            synchronized(Counter.lock) {
36
                Counter.studentCount -= 1;
37
            }
38
        }
39
    }
40
}
41

42
class AddTeacherThread extends Thread {
43
    public void run() {
44
        for (int i=0; i<10000; i++) {
45
            synchronized(Counter.lock) {
46
                Counter.teacherCount += 1;
47
            }
48
        }
49
    }
50
}
51

52
class DecTeacherThread extends Thread {
53
    public void run() {
54
        for (int i=0; i<10000; i++) {
55
            synchronized(Counter.lock) {
56
                Counter.teacherCount -= 1;
57
            }
58
        }
59
    }
60
}

1
synchronized(Counter.lockStudent) {
2
    ...
3
}

1
synchronized(Counter.lockTeacher) {
2
    ...
3
}