多线程编程

一、Thread

Thread类是java标准库里面的类，表示的是线程，每个创建的Thread实例都是和系统中的一个线程是对应的。

Thread的用法有很多，接下来一一介绍：

1.1 Thread用法一

创建一个子类，继承自Thread，重写Thread中的run方法，run方法内部就包含了这个线程要执行的代码（每个线程都是独立的生产线，要执行一些代码）

// 标准库里提供了一个 Thread 这个类. 就使用这个类来表示线程.
// 这个样子没有真正创建出线程来
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("hello Thread!!");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        // 真正创建出这个线程要做两步：
        // 1、创建 Thread 实例，此处是MyThread1这个实例对象；
        MyThread1 t = new MyThread1();
        
        // 2、调用Thread里面的.start() 方法，才是真正在系统内部创建出线程！！
        t.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

.start() 的方法就会在系统中创建出新的线程出来，新的线程就是会执行子类里面的 run() 方法中的代码。

main 方法本身默认也是会执行出一个线程的（一个进程中不可能有一个线程都没有，至少得有一个线程），以往的代码中，每个代码的main方法，都对应出一个线程来，现在通过 t.start()，又创建出一个新的线程出来。

我们这里也可以在main方法中打印日志看一看他们是否是并发执行的。

class MyThread2 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread!");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        // 主线程
        MyThread2 t =new MyThread2();
        t.start();

        while(true) {
            System.out.println("hello main!!");

            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

Thread.sleep(1000); 我们这里用到了sleep这个方法，这里面的方法单位是 ms，sleep操作也可以叫做“休眠”，调用了sleep，该线程就暂时 relax ，不干活，在这休息期间线程也不会占用CPU，不会继续执行后续命令。

为什么使用 sleep 因为 while（true）死循环太快了，电脑吃不消，让两个线程同时休息1秒，再执行，相对来说对电脑要好一点。

有图可知，这两个线程的打印是交替进行的，交替进行也可说明，两个线程是并发执行的。

但是这里面的并发，并不是完全是“交替”，偶尔也会出现，我两条，你一条的情况，或者我一条，你两条的情况。

多线程之间执行的先后顺序，是不能完全确定的。当1秒过后，系统到底该执行那个线程，是不确定的。（这取决于操作系统内部调度代码的具体实现）。如果多个线程之间没有手动的控制先后顺序，那么就会认为多个线程之间执行的是“随机顺序”。这个“随机顺序”特别不稳定，容易出现BUG。

• 给大家推荐一个JDK自带的 jconsole 工具，这个工具更直观的看到两个代码中的线程，在自己的安装的 JDK 的bin目录下。

• 用法

1.2、Thread用法二 （Runnable）

创建类，实现 Runnable 接口。Runnable接口也是标准库中自带的一个接口，也是要重写run（）方法。

创建 Thread 实例，然后把刚才的 Runnable 实例给 设置进去。

package thread;


class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 描述了任务具体要执行的任务
        while (true) {
            System.out.println("hello thread!!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();

        while(true) {
            System.out.println("hello main!");
            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

这种写法，是通过 实现 Runnable 实现的，（通过 Runnable 这种方式，相当于把 “要执行的任务” 和 Thread 类，进行分离（解耦合）；用法一的写法是 继承 Thread 实现的。

1.3、Thread用法三

这种写法是匿名内部类;

package thread;

public class Demo4 {
    // 匿名内部类的方法
    public static void main(String[] args) {
        // 父类引用指向了子类的对象 -------- 多态
        // 创建一个匿名的子类，继承自 Thread 父类
        Thread t = new Thread() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello thread!!");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();

        while(true) {
            System.out.println("hello main");
            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

1.4、Thread用法四

创建了一个Runnable的匿名内部类，匿名内部类中实现 run（）方法，描述任务，Thread并创建出实例，直接交给 Thread 来进行使用。

public class Demo5 {
    public static void main(String[] args) {
       Thread t = new Thread(new Runnable() {
           @Override
           public void run() {
               while (true) {
                   System.out.println("hello thread");
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
       t.start();

       while(true) {
           System.out.println("hello main");
           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

1.5、Thread用法五（lambda)

使用 lambda 表达式来使用

public class Demo6 {
    public static void main(String[] args) {
        // 重写的run（）无参
        Thread t = new Thread(()->{
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        while (true) {
            System.out.println("hello main");
            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

总结：

1、描述清楚要执行的任务是啥（run（）方法）

2、把这个任务给加到一个Thread 实例中，并调用 start 方法。

二、run 和 start 的区别

run（） 方法是一个普通的方法，只是会当做普通的方法执行，不会创建出新的线程出来，所以此时就只有一个 main线程，只有等到main线程中的run（）方法调用执行完，才会执行第二个循环。

1、start（）这个方法，只要一执行就会创建出一个新的线程出来，新线程就会执行run（）方法，

2、run（）方法自身不具备创建新线程的能力，仍然在旧的线程中执行。

三、并发编程有何用？

并发编程（多线程）最明显的优势，就是针对 ”CPU密集型“ 的程序，能提高效率。

1、”CPU密集型“：程序进行大量的运算

可以理解两个人干活的效率，总比一个人干活的效率高，但是提升的效率也不一定正好是减少 50% ，因为系统中不能保证两个线程是完全 并发 执行的。（尤其是系统资源本身比较紧张的情况下）

所以想要提升速度的话，可以考虑使用多线程进行任务拆分，提高效率。

并发编程追求目标，也就是通过多线程，可以更充分的利用多核CPU的计算资源。

四、Thread的方法和属性

一、 Thread（String name) ,通过 name 是可以给线程取名字的，方便程序员调试，

可以打开 jconsole.exe 工具 confirm 一下，如果不取名字，JVM 默认会给指定的名字，形如 Thread-0，Thread-1…

关于进程的结束：

1、创建出来的是一个 非后台 线程，此时及时 main 线程执行完了，java的进程仍然要继续进行执行，等到所有的 非后台线程执行完，java的进程才会退出。

2、如果一个线程是 后台线程 ，此时后台线程就不会影响到 Java 进程的结束。

二、IsAlive

1、这个属性和方法表示，Thread 变量 t，和操作系统内核中的线程，生命周期不是完全相同的；t被创建出来了，内核里面不一定有对应的线程，必须要通过 t.start() 来调用，才有对应的线程。

2、内核中的线程被销毁了（执行结束），t 不一定销毁， 内核线程的 run 方法执行完，也就结束了，t 要等到 GC 来进行释放。

拿到 t 变量，不能断言出内核里的对应线程也是同样存在的，只有通过 `IsAlive` 就是来判断：
a、true，说明内核的线程在
b、false，内核的线程已经执行完了，或者还没开始执行。
1
2
3

五、控制线程的具体操作

1、创建线程；.start()方法，这个之前就已经讲过了，不再赘述，主要掌握，.start() & run() 方法之间的区别就行。

5.2、中断线程（让线程结束）:

​ run 方法执行完，线程随之就结束了。

​ 方法：（1）、强行终止进程，线程随之也就结束了；（特殊手段）

​ （2）、手动设置标志位，作为循环判断的条件；

public class Demo7 {
    // 通过一个变量来控制线程是否结束
    private static boolean isQuit = false;

    public static void main(String[] args) {
        Thread t = new Thread(()->{
           while (!isQuit) {
               System.out.println("hell thread!!");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isQuit = true;
    }
}
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

这里的 isQuit 是在t 线程读取，main线程修改。

（3）、借助 Thread 实例中自己提供的一个标志位 interrupt（） ，不能直接引用标志位的变量，但是可以通过一些方法来进行 读和写的操作

​ a、通过 Thread 中的 isIntrrupted 方法来判定标志位是否为 true；（true表示线程应该退出）----读操作

​ b、通过 Thread 中的 interrupt 方法，来把这个标志位设为 true；（表示中断）--------写操作

public class Demo8 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                // 默认为false
                while (!this.isInterrupted()) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        // catch 只是打印出异常，会继续执行，需要break跳出循环，来修改 interrupt 的值
                        break;
                    }
                }
            }
        };
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
		// 进行修改，改成true，表示线程中断。
        t.interrupt();
    }
}
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

由图可知如果没有加break，只会打印出异常，线程继续执行；

调用 interrupt 方法的时候，如果线程是“就绪状态”，此时是直接修改 线程中的标志位。如果是“阻塞状态”，此时会引起 InterruptedException 异常。

在 t 线程代码中，存在两种情况：

1、执行打印和 while 循环判定。（线程处于“就绪状态”）

2、进行sleep（线程处于“阻塞状态”）

5.3、等待线程（join）

等待指定的线程执行完。

such as：在main线程中，调用 t.join()，那么就是让main来等待 t 这个线程执行完毕。

当调用join（） 的时候，就会“阻塞等待”。效果类似于 sleep 。

public class Demo9 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i< 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        System.out.println("main方法中 t 线程还没有执行完");

        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t 线程执行完了");
    }
}
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

代码执行到join就不再继续往下走了，会进入等待，直到 t 线程执行完 （t线程中的run方法结束），然后join才会继续。

作用：通过 join 可以控制线程结束的先后顺序 （手动控制，谁先谁后），在多线程之间调度的顺序是不确定的（抢占式），这种的不确定性会给代码添加很多的偶然性和随机性，就会让代码出现奇怪的bug。这里的 join 就是手动控制线程执行顺序的一种办法，join 主要是用来控制结束的顺序。

这里是带参数和不带参数的 join 方法，不带参数就是“死等”，带参数就是通过参数设置一个等待时间（ms），这个等待时间就表示join最多等多久（超时时间）。

5.4、获取当前线程的应用

在某个线程的代码中，拿到当前这个线程对应的 Thread 对象的引用；拿到这个引用才能做一些后续的操作，很多和线程相关的操作，都是依赖这样的引用。

1、如果是继承了 Thread 来创建了线程，此时直接在 run 方法中通过 this，就能拿到这个线程的实例。

2、但是我们有一个跟常键的方法是使用 Thread 里面的静态方法，currentThread（），上面也有提及，那个线程调用了这个静态的方法，就能够返回那个线程的 Thread 实例引用，这样的获取方法可以在任何方法中使用。

注意：

这里为什么会变红，因为我们是在Runnable方法里面调用的，因此此刻 this 这里指向的是 Runnable，所以就没有 Thread 类里面的方法和属性了

切记自己到底是引用的什么类，不管怎么说都要引用的是 Thread 的实例。

但是我们也有更好的解决方法，那就是使用我们的静态类，currentThread（）！！！

此时，虽然run是 Runnable 方法，但是通过 Thread 的 currenThread（） 来获取到线程的实例；

Thread.currentThread()
1

这个方法是在那个线程调用的，就返回那个线程的实例。

5.5、线程的休眠 sleep

调用线程的sleep方法，线程就会进行阻塞等待，等待的时间取决于 sleep 中指定的时间。

在一个进程中会有多个线程，每个线程都对应着一个PCB（不知道PCB是啥，点击这个链接了解），此时进程中就会有一组 PCB，操作系统就是以 PCB 为单位进行调度执行的。

而我们的 PCB 在进程中是以双向链表组织管理的，操作系统调度 PCB 的时候，就是从 就绪队列 中挑出一个 PCB 去CPU 上执行。

但是 sleep 相当于阻塞了，那么阻塞队列这边就会把就绪队列里面的一个PCB（链表）给移动到阻塞队列里面来，等到sleep等待的时间到了实际成熟了，这个PCB再回到就绪队列中。

区分：

像通过 sleep 产生的阻塞的操作，时机成熟 => 时间到了；

通过 join 产生的阻塞操作，时机成熟 => 对应的线程结束了

这里当sleep的时间到了 PCB 回到就绪队列里面并不会立即在 CPU 上面执行，那么什么时候 CPU 会调用回到就绪队列里面的PCB 就说不准了，因为操作系统调度线程是存在一定的随机性）。

五、线程的状态

线程里面的状态会更详细一些，java也是对线程进行了封装，并且也给出了一些具体的描述，多了解线程的状态是有用的，主要是调试一些多线程程序的时候，会用的上。

public class ThreadState {
	public static void main(String[] args) {
		for (Thread.State state : Thread.State.values()) {
			System.out.println(state);
		}
	}
}
1
2
3
4
5
6
7

这段代码就是把java线程里面的所有状态都打印出来， Thread.State 这是一个枚举类型。

• NEW: 安排了工作, 还未开始行动
• RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
• BLOCKED: 这几个都表示排队等着其他事情
• WAITING: 这几个都表示排队等着其他事情
• TIMED_WAITING: 这几个都表示排队等着其他事情
• TERMINATED: 工作完成了

虽然这上面有很多种状态，但是最关键的还是只有两种 就绪和阻塞 ，java线程的这些状态只是把这两个大类型的状态给细分了，

NEW:把 Thread 对象创建出来了，但是内核里面线程还没有创建出来 （没调用 start 方法）。

TERMINATED：内核里面的线程结束了，然而 Thread 对象还在。

RUNNABLE：就绪状态 （重要的一种状态）

TIMED_WAITING: 通过 sleep 产生的。

BLOCKED：等待锁产生的状态。（这也是阻塞，只不过是锁的阻塞，重要）

WAITING：通过 wait 方法触发，与锁有着密切的联系。（重要）

线程状态之间转换关系图：

---

这篇帖子介绍了多线程编程的基本用法和基础概念，都是必掌握，下一篇帖子更重要，关于”线程的安全“ ，这是整个多线程中最重要的关键点！！！

铁汁们，觉得笔者写的不错的可以点个赞哟❤🧡💛💚💙💜🤎🖤🤍💟，收藏关注呗，你们支持就是我写博客最大的动力！！！！