java EE初阶 — 如何进行多线程编程

1.java如何进行多线程编程

Thread 是java操作多线程最核心类。
使用Thread不需要import导入别的包，因为它是在java.lang下面

1.1 最基础的多线程代码

package thread;

class MyThread extends Thread{
    //在此类中重写run方法
    @Override
    public void run() {
        System.out.println("hello world");
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();//线程中的特殊方法 - 创建一个线程
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在thread包中创建一个对象，Mythread子类继承Thread父类。
重写Thread类中的run方法输出hello world。
start是线程中的特殊方法，在这里的作用是创建一个新的线程，而不是调用run。
新的线程负责调用run方法来输出hello world。

新的进程调用操作系统的API，通过操作系统内核创建新线程的PCB。
并且把要执行的指令交给这个PCB。
当这个PCB被调度到CPU上的时候，也就执行到了线程run方法中的代码了。

如果run方法执行完毕，这个新的线程会销毁。

1.2 线程的优势

改动一下上面的代码：

package thread;

class MyThread extends Thread{
    //在此类中重写run方法
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world");
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();//线程中的特殊方法 - 创建一个线程
        while (true) {
            System.out.println("hello java");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

如果此时的代码时非线程的，程序会死循环的输出 hello world，并且没有机会执行 hello java
但是实际情况是，这两条输出语句都会执行，并且都是死循环。

为了方便观察，调用sleep设置睡眠时间为1秒。

package thread;

class MyThread extends Thread{
    //在此类中重写run方法
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world");
            //睡一会儿
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();//线程中的特殊方法 - 创建一个线程
        while (true) {
            System.out.println("hello java");
            //睡一会儿
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

先执行 hello world 还是先执行 hello java 是不确定的。
操作系统调度线程的时候，是“抢占式执行的”，具体哪个先哪个后，是不确定的。
这要取决与操作系统的调度器具体的实现策略。

虽然有优先级，但是在应用程序层面上无法修改。
从应用程序（代码）的角度，看到的效果，就好像是线程的调度效果好像是随机的一样。

内核里本身并不是随机的，但是干预的元素太多了，并且应用程序这一层也无法感知到细节，就只能认为是随机的了。

抢占式执行，随机访问就是线程安全问题的罪魁祸首。

如果其中一条语句无法输入，不会影响另一条语句。

把输出 hello world 的语句给屏蔽了，但是不会影响输出 hello java

class MyThread extends Thread{
    //在此类中重写run方法
    @Override
    public void run() {
        while (true) {
            //System.out.println("hello world");
            //睡一会儿
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

就像是，张三和李四去学校，张三不来了并不会决定李四来不来。

start 和 run 之间的区别：

start是真正上创建了一个进程（从系统这里创建的），线程是独立的执行流。

run只是描述了线程要干的活是什么，如果直接在main中调用 run 。
此时没有创建新线程，全是main线程一个人干活。

2.java中创建线程的方法

2.1 继承Thread 重写run

第一种方法就是前面介绍的方法。

2.2 实现Runnable 接口

package thread;

//Runnable 的作用是描述一个要“执行的任务”，run方法就是任务的执行细节
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello 张三");
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        //这只是描述了任务
        Runnable runnable = new MyRunnable();
        //把任务交给线程来执行
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

如果未来要更改代码，不用多线程，
而是使用多进程，或者线程池、协程…此时的代码改动比较小。

2.3 使用匿名的内部类，继承 Thread

package thread;

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

上面方法先是创建了一个Thread的子类（子类没有名字），所以才叫做匿名。
然后是创建了子类的实例，并且让thread引用指向该实例。

2.4 使用匿名类。继承 Runnable

package thread;

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

这个写法本质和2相同。
只不过是把实现 Runnable 任务交给了匿名内部类的语法。

此处是创建了一个类，实现 Runnable ，同时创建了类的实例，并且传给 Thread 的构造方法。

2.5 使用 Lambda 表达式（最简答、最推荐）

package thread;

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

把任务用 Lambda 表达式来描述
直接把 Lambda 传给 Thread 构造方法。