【Java学习笔记】线程基础

线程基础

一、基本概念

1. 程序

是为完成特定任务，用某种语言编写的一组指令的集合（即代码）

2. 进程

（1）进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程（有它自身的产生，存在和消亡的过程）

（2）进程的启动会占用相应的资源（CPU、内存等）

（3）通俗理解：进程是指运行的程序，启动一个程序（打开一个软件）的过程就是启动一个进程，关闭程序的过程就是进程的消亡过程

3. 线程

（1）线程是由进程创建的，是进程的一个实体

（2）一个进程可以拥有多个线程

（3）举例：百度网盘同时下载多个文件，这就是多线程

4. 单线程

同一个时刻，只允许执行一个进程

5. 多线程

同一个时刻，可以执行多个线程（举例：QQ 可以同时打开多个聊天窗口）

6. 并发

（1）同一个时刻，多个任务交替执行，造成一种 “ 貌似同时 ” 的错觉

（2）实例：单核 CPU 实现的多任务就是并发

解释：由一个 CPU 来回切换任务，然后执行，这个过程很迅速

7. 并行

（1）同一个时刻，多个任务同时执行，多喝 CPU 可以实现并行，并发和并行

（2）实例：多个 CPU 同时存在，每个 CPU 执行自己的进程

注意：每个 CPU 也可以实现并发

8. 创建线程的两种方法

• 继承 Thread 类，重 run 方法

• 实现 Runnable 接口，重写 run 方法

---

二、继承 Thead 类

代码示例

package Thread;public class main {public static void main(String[] args) {a a = new a();a.start();int i = 0;while (true) {System.out.println("main " + ++i + "--->" + Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 5) {break;}}}
}class a extends Thread {@Overridepublic void run() {int i = 0;while (true) {System.out.println("hello " + ++i + "--->" +  Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 10) {break;}}}
}

运行结果

main 1--->main
hello 1--->Thread-0
main 2--->main
hello 2--->Thread-0
hello 3--->Thread-0
main 3--->main
main 4--->main
hello 4--->Thread-0
main 5--->main
hello 5--->Thread-0
hello 6--->Thread-0
hello 7--->Thread-0
hello 8--->Thread-0
hello 9--->Thread-0
hello 10--->Thread-0

代码分析

（1）sleep()方法会抛出异常，需要用 try - catch 包裹

（2）关系：sleep()方法休眠的单位是毫秒，1000 毫秒=1 秒

（2）获取线程名称的方法：Thread.currentThread().getName()

问题：为什么调用 start()方法可以调用 run()方法，而不是直接调用 run()方法？

（1）真正启动线程的是 start()方法，而不是 run()方法，run()方法是普通方法，会造成线程阻塞

start()方法的底层探究

1. 首先 start()方法会调用 start0()方法

2. start0()方法是native方法，由 JVM 机调用

3. 何时启动线程还需根据其他依据综合考虑

（2）如调用 run()方法，并不会启动线程，而是等 run()方法执行完之后才会启动 main 方法的调用

public class main {public static void main(String[] args) {a a = new a();a.run();int i = 0;while (true) {System.out.println("main " + ++i + "--->" + Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 5) {break;}}}
}class a extends Thread {@Overridepublic void run() {int i = 0;while (true) {System.out.println("hello " + ++i + "--->" +  Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 10) {break;}}}
}

运行结果

hello 1--->main
hello 2--->main
hello 3--->main
hello 4--->main
hello 5--->main
hello 6--->main
hello 7--->main
hello 8--->main
hello 9--->main
hello 10--->main
main 1--->main
main 2--->main
main 3--->main
main 4--->main
main 5--->main

结论：这里 run()方法的线程名就是 main，即调用 run()方法并没有启动线程

注意：主线程的结束并不会导致进程的结束，需要等到所有线程都执行完成进程才会退出

---

三、实现 Runnable 接口

引出：由于 Java 是单继承机制，如果类继承了其他类，这个时候可以通过实现接口的方式创建线程

1. 代码示例

package Thread;public class main {public static void main(String[] args) {a a = new a();Thread thread = new Thread(a);thread.start();int i = 0;while (true) {System.out.println("main " + ++i + "--->" + Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 5) {break;}}}
}class a implements Runnable {@Overridepublic void run() {int i = 0;while (true) {System.out.println("hello " + ++i + "--->" +  Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i == 10) {break;}}}
}

运行结果

main 1--->main
hello 1--->Thread-0
main 2--->main
hello 2--->Thread-0
hello 3--->Thread-0
main 3--->main
main 4--->main
hello 4--->Thread-0
hello 5--->Thread-0
main 5--->main
hello 6--->Thread-0
hello 7--->Thread-0
hello 8--->Thread-0
hello 9--->Thread-0
hello 10--->Thread-0

代码分析

（1）实现了 Runnable 接口，但是这个接口中并没有 start()方法，不可以直接调用

（2）通过把 a 对象作为参数传入构造器中，调用构造器创建 Thread 对象，调用 Thread 对象的 start()方法

2. 问题：为什么调用 Thread 的 start()方法就可以调用 a 类的 run()方法？

回答：底层采用了静态代理模式

理解：既然 Runnable 接口没有 start()方法，那就借助 Thread 类，让它来实现 start()方法（体现代理）

3. 模拟 Thread 类，理解实现原理

public class main {public static void main(String[] args) {test test = new test();Thread_proxy thread_proxy = new Thread_proxy(test);thread_proxy.start();}
}class Thread_proxy implements Runnable{private Runnable target = null;// 构造器public Thread_proxy(Runnable target) {this.target = target;}// 实现 run() 方法@Overridepublic void run() {if(target != null){target.run();}}public void start(){start0();}public void start0(){run();}
}class test implements Runnable{@Overridepublic void run() {System.out.println("调用了 test 类的 run() 方法");}
}

代码分析

（1）创建 Thread_proxy 类，实现 Runnable()接口，模拟 Thead 类

（2）创建 test 类，实现 Runnable()接口

（3）在主函数中创建 Thread_proxy 对象，在构造器中传入 test 对象，调用 Thread_proxy 对象的 start()方法来启动线程

底层分析

1. 为什么可以传入 test？

因为 test 是实现了 Runnable 接口的一个类，根据接口的多态，接口类型可指向实现该接口的类对象

2. 如何实现调用 test 类的 run()方法的？

（1）thread_proxy 调用 start()方法，最终调用 start0()方法，该方法调用该类中的 run()方法

（2）此时 target 不为空（target 指向了传入的 test 对象），根据动态绑定机制，这个时候会调用 test 类的 run()方法