JavaSE 进阶 - 第24章 多线程（一）
JavaSE 进阶 - 第24章 多线程（一）
- 1、多线程概述
- 2、实现线程的 2 种方式
- 3、线程对象的生命周期
- 4、关于线程java.lang.Thread的一些方法
- 传送门
1、多线程概述
1.1、什么是进程？什么是线程？
进程是一个执行中的应用程序（1个进程是1个运行中的软件）。
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。
1.2、对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后：
会先启动JVM，而JVM就是一个进程：
JVM再启动一个主线程调用main方法。
同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的java程序中至少有两个线程并发：一个是垃圾回收线程，一个是执行main方法的主线程。
1.3、进程和线程是什么关系？举个例子
进程可以看做是现实生活当中的公司。
线程可以看做是公司当中的某个员工。
注意：
进程A和进程B的内存独立不共享。（阿里巴巴和京东 两个公司 资源不会共享的！）
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。
线程A和线程B呢？
在java语言中：
线程A和线程B，堆内存和方法区内存共享。
但是栈内存独立，【一个线程一个栈】！！！
假设启动10个线程，会有10个栈空间，
每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
1.4、思考一个问题：
使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？
是的，main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。
1.5、java中多线程机制的目的：提高程序的处理效率。
火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
所以多线程并发可以提高效率。
1.6、分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。
4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
什么是真正的多线程并发？
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。
单核的CPU表示只有一个大脑：
不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。
对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于
CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情同时在做！！！！！
线程A：播放音乐
线程B：运行魔兽游戏
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，
给我们的感觉是同时并发的。
电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，
人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像
一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在
这个期间计算机可以进行亿万次的循环。
所以计算机的执行速度很快。
【练习题】：分析以下程序，除垃圾回收线程之外,有几个线程？
/*
分析以下程序，除垃圾回收线程之外,有几个线程？
1个线程。（因为程序只有1个栈。）
main begin
m1 begin
m2 begin
m3 execute!
m2 over
m1 over
main over
一个栈中，自上而下的顺序依次逐行执行！
*/
public class ThreadTest01 {
public static void main(String[] args) {
System.out.println("main begin");
m1();
System.out.println("main over");
}
private static void m1() {
System.out.println("m1 begin");
m2();
System.out.println("m1 over");
}
private static void m2() {
System.out.println("m2 begin");
m3();
System.out.println("m2 over");
}
private static void m3() {
System.out.println("m3 execute!");
}
}
2、实现线程的 2 种方式
java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。
第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。
____________________________________________________________________
// 定义线程类
public class MyThread extends Thread{
public void run(){
// 编写程序，这段程序运行在分支线程中（分支栈）
}
}
____________________________________________________________________
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();
____________________________________________________________________
第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
____________________________________________________________________
// 定义一个可运行的类
public class MyRunnable implements Runnable {
public void run(){
// 编写程序，这段程序运行在分支线程中（分支栈）
}
}
____________________________________________________________________
// 创建一个可运行的对象
//MyRunnable r = new MyRunnable();
// 将可运行的对象封装成一个线程对象
//Thread t = new Thread(r);
// 创建线程对象
Thread t = new Thread(new MyRunnable()); // 合并代码
// 启动线程
t.start();
____________________________________________________________________
注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。
【实例1】实现多线程的第 1 种方式，及run和start的区别
/* 实现线程的第 1 种方式：
编写一个类，直接继承java.lang.Thread，重写run方法。
怎么创建线程对象？ new就行了。
怎么启动线程呢？ 调用线程对象的start()方法。
亘古不变的道理：方法体当中的代码永远都是自上而下的顺序依次逐行执行的。
以下程序的输出结果有这样的特点：
有先有后。
有多有少。
分支线程和main线程的内容交替输出
*/
public class ThreadTest02 {
public static void main(String[] args) {
// 这里是main方法，这里的代码属于主线程，在主栈中运行。
// 新建一个分支线程对象
MyThread t = new MyThread();
//t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
// 启动线程
t.start();
// start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
// 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
// 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
// run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
// 这里的代码还是运行在主线程中。
for(int i = 0; i < 1000; i++){
System.out.println("主线程--->" + i);
}
}
}
class MyThread extends Thread {
@Override
public void run() {
// 编写程序，这段程序运行在分支线程中（分支栈）。
for(int i = 0; i < 1000; i++){
System.out.println("分支线程--->" + i);
}
}
}
/*运行结果（每次运行结果都不同）：
主线程--->0
分支线程--->0
主线程--->1
分支线程--->1
主线程--->2
分支线程--->2
主线程--->3
主线程--->4
主线程--->5
分支线程--->3
......
*/
（1）如果调用run方法，只是单线程内存图：
（2）应该调用start方法，多线程内存图：
【实例2】实现多线程的第 2 种方式
//实现线程的第 2 种方式，编写一个类实现java.lang.Runnable接口。
public class ThreadTest03 {
public static void main(String[] args) {
// 创建一个可运行的对象
//MyRunnable r = new MyRunnable();
// 将可运行的对象封装成一个线程对象
//Thread t = new Thread(r);
// 创建线程对象
Thread t = new Thread(new MyRunnable()); // 合并代码
// 启动线程
t.start();
for(int i = 0; i < 100; i++){
System.out.println("主线程--->" + i);
}
}
}
// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("分支线程--->" + i);
}
}
}
【实例3】采用匿名内部类方式，创建线程对象
//采用匿名内部类方式，创建线程对象
public class ThreadTest04 {
public static void main(String[] args) {
// 创建线程对象，采用匿名内部类方式。
// 这是通过一个没有名字的类，new出来的对象。
Thread t = new Thread(new Runnable(){
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("t线程---> " + i);
}
}
});
// 启动线程
t.start();
for(int i = 0; i < 100; i++){
System.out.println("main线程---> " + i);
}
}
}
3、线程对象的生命周期
线程的生命周期存在五个状态：新建、就绪、运行、阻塞、死亡
- 新建：采用 new语句创建完成
- 就绪：执行 start 后
- 运行：占用 CPU 时间
- 阻塞：执行了 wait 语句、执行了 sleep 语句和等待某个对象锁，等待输入的场合
- 终止：退出 run()方法
4、关于线程java.lang.Thread的一些方法
- 1、static Thread currentThread()
- 2、String getName()
- 3、void setName(String name)
- 4、static void sleep(long millis)
- 5、void interrupt()
- 6、void stop()
【具体介绍】：
1、获取当前线程对象————static Thread currentThread()
Thread t = Thread.currentThread();
返回值t就是当前线程。
2、获取线程对象的名字———— String getName()
String name = 线程对象.getName();
3、修改线程对象的名字———— void setName(String name)
线程对象.setName("线程名字");
当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）
Thread-0
Thread-1
Thread-2
Thread-3
.....
public class ThreadTest05 {
public static void main(String[] args) {
//currentThread就是当前线程对象
// 这个代码出现在main方法当中，所以当前线程就是主线程。
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName()); //main
// 创建线程对象
MyThread2 t = new MyThread2();
// 设置线程的名字
t.setName("t1");
// 获取线程的名字
String tName = t.getName();
System.out.println(tName); //t1
MyThread2 t2 = new MyThread2();
t2.setName("t2");
System.out.println(t2.getName()); //t2
t2.start();
// 启动线程
t.start();
}
}
class MyThread2 extends Thread {
public void run(){
for(int i = 0; i < 100; i++){
// currentThread就是当前线程对象。当前线程是谁呢？
// 当t1线程执行run方法，那么这个当前线程就是t1
// 当t2线程执行run方法，那么这个当前线程就是t2
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "-->" + i);
}
}
}
/*
main
t1
t2
t2-->0
t1-->0
t2-->1
t1-->1
t1-->2
t2-->2
t1-->3
t2-->3
t1-->4
t2-->4
t1-->5
t2-->5
...
*/
4、线程的sleep方法————static void sleep(long millis)
1、静态方法：Thread.sleep(1000);
2、参数是毫秒
3、作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中，A线程就会进入休眠。
这行代码出现在B线程中，B线程就会进入休眠。
4、Thread.sleep()方法，可以做到这种效果：
间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
public class ThreadTest06 {
public static void main(String[] args) {
// 让当前线程进入休眠，睡眠5秒
// 当前线程是主线程！！！
/*try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
// 5秒之后执行这里的代码
//System.out.println("hello world!");
for(int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
//最终输出时，是每过一秒，输出一行main--->。。
try {
Thread.sleep(1000);// 睡眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/*输出时，是每过一秒，输出一行：
main--->0
main--->1
main--->2
main--->3
main--->4
main--->5
main--->6
main--->7
main--->8
main--->9
*/
关于Thread.sleep()方法的一个面试题：
//关于Thread.sleep()方法的一个面试题：
public class ThreadTest07 {
public static void main(String[] args) {
// 创建线程对象
Thread t = new MyThread3();
t.setName("t");
t.start();
// 调用sleep方法
try {
// 问题：这行代码会让线程t进入休眠状态吗？
t.sleep(1000 * 5);
// 不会, 在执行的时候还是会转换成：Thread.sleep(1000 * 5);（sleep方法是静态方法）
// 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。并不是t线程
// 这样代码出现在main方法中，main线程睡眠。
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒之后这里才会执行。
System.out.println("hello World!");
}
}
class MyThread3 extends Thread {
public void run(){
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
/*
t--->0
t--->1
t--->2
t--->3
...
t--->9997
t--->9998
t--->9999
hello World! // 5秒之后这里才会执行。
*/
5、终止线程的睡眠（sleep）———— void interrupt()
sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程？？
void interrupt()方法
注意：这个不是终止线程的执行，是终止线程的睡眠。
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable2());
t.setName("t");
t.start();
// 希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了。）：
try {//让当前线程（main主线程睡眠5秒）
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒后执行这里：
// 终止t线程的睡眠（这种终止睡眠的方式依靠了java的异常处理机制。）
t.interrupt(); // 打断，一盆冷水过去！
}
}
class MyRunnable2 implements Runnable {
// 重点：run()当中的异常不能throws，只能try catch
// 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---> begin");
try {
Thread.sleep(1000 * 60 * 60 * 24 * 365);// 睡眠1年
} catch (InterruptedException e) {
// 打印异常信息
e.printStackTrace();
}
//1年之后才会执行这里
System.out.println(Thread.currentThread().getName() + "---> end");
// 调用doOther
//doOther();
}
// 其它方法可以throws
/*public void doOther() throws Exception{
}*/
}
/*运行结果：（开始时下面第一行直接出现，然后5秒后，后面的紧接着出现）
t---> begin
java.lang.InterruptedException: sleep interrupted
at java.base/java.lang.Thread.sleep(Native Method)
at com.bjpowernode.java.thread.MyRunnable2.run(ThreadTest08.java:33)
at java.base/java.lang.Thread.run(Thread.java:830)
t---> end
*/
6、强行终止一个线程的执行———— void stop()
已过时。 该方法具有固有的不安全性。
这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，
线程没有保存的数据将会丢失。不建议使用。
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable3());
t.setName("t");
t.start();
// 模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒之后强行终止t线程
t.stop(); // 已过时（不建议使用。）
}
}
class MyRunnable3 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++){ //输出10行。每输出 1 行，睡眠 1 秒
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000); //睡眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/*运行结果：（每一秒输出了一行，一共5秒）
t--->0
t--->1
t--->2
t--->3
t--->4
*/
7、合理的终止一个线程的执行:
首先，在实现Runnable接口的类里面，打一个布尔标记： boolean run = true;
然后在run方法里面做判断使用，当标记run的值为true时，执行run方法，
当想要什么时候终止线程的执行时，只要把标记修改为false: r.run = false;
就结束了。
public class ThreadTest10 {
public static void main(String[] args) {
MyRunable4 r = new MyRunable4();
Thread t = new Thread(r);
t.setName("t");
t.start();
try {// 模拟5秒
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止线程
// 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
r.run = false;
}
}
class MyRunable4 implements Runnable {
boolean run = true;// 打一个布尔标记（在下面的run方法里面做判断使用）
@Override
public void run() {
for (int i = 0; i < 10; i++){//输出10行。每输出 1 行，睡眠 1 秒
if(run){//布尔标记 run 为 true，则执行下面的
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
// return就结束了，你在结束之前还有什么没保存的。
// 在这里可以保存呀。
//save....
return;//终止当前线程
}
}
}
}
/*运行结果：（每一秒输出了一行，一共5秒）
t--->0
t--->1
t--->2
t--->3
t--->4
*/
传送门
上一章：JavaSE 进阶 - 第23章 IO流
下一章：JavaSE 进阶 - 第24章 多线程（二）