Java基础程序——多线程

目录

1、多线程介绍

2、程序运行原理

3、主线程

4、Thread 类

5、创建线程方式——继承Thread类

6、继承Thread类原理

7、多线程的内存图解

8、获取线程名称

9、创建线程方式——实现Runnable接口

10、实现Runnable的原理

11、实现Runnable的好处

12、线程的匿名内部类使用

---

1、多线程介绍

• 进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

• 线程：线程是进程中的一个执行单元，负责当前进行中程序的执行，一个进程中至少有一个线程。一个进程中可以有多个线程，这个应用程序则可以称之为多线程程序
• 总结：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
• 什么是多线程？就是一个程序中有多个线程在同时执行。

单线程程序与多线程程序的区别：

1. 单线程程序：有多个任务但只能依次执行。当上一个任务执行结束后，下一个任务开始执行
2. 多线程程序： 有多个任务可以同时执行。

---

2、程序运行原理

• 分时调度： 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
• 抢占式调度： 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个 (线程随机性)，Java使用的为抢占式调度。

3、主线程

在运行Java程序时，虚拟机会从main方法开始执行我们的程序代码，一直把main方法的代码执行结束。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码 是不会被马上执行的。

class Demo{
String name;
Demo(String name){
this.name = name;
}
void show() {
for (int i=1;i<=10000 ;i++ ) {
System.out.println("name="+name+",i="+i);
}
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo("小强");
Demo d2 = new Demo("旺财");
d.show();
d2.show();
System.out.println("Hello World!");
}
}

若在上述代码中show方法中的循环执行次数很多，这时在d.show();下面的代码是不会马上执行的，并且在dos窗口会看到不停的输出  name=小强,i=值   这样的语句。为什么会这 样呢？

• 原因：JVM启动后，必然有一个执行路径（线程）从main方法开始的，一直执行到main方法结束，这个线程在Java中称为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留实践过长，则无法马上执行下面的程序，需要等待循环结束后才能继续执行。

---

4、Thread 类

Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

 构造方法：

Thread() 分配一个新的 Thread对象。

Thread(String name) 分配一个新的 Thread对象。

常用方法：

void	join() 等待该线程死亡。
void	run() 如果该线程是使用一个单独的 Runnable运行对象的构造，然后 Runnable对象的 run方法被调用；否则，该方法不返回。
static void	sleep(long millis) 当前正在执行的线程休眠（暂停执行）为指定的毫秒数，根据精度和系统定时器和调度的准确性。
void	start() 导致该线程开始执行；java虚拟机调用这个线程的 run方法。

 创建新执行线程有两种方法：

• 将类声明为Thread的子类。该子类应该重写Thread类的run方法。创建对象，开启线程。run方法相当于其他线程的main方法
• 声明一个实现Runnable接口的类，然后该类实现run方法，然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

---

5、创建线程方式——继承Thread类

创建线程的步骤：

1.  定义一个类继承Thread。
2. 重写run方法。
3. 创建子类对象，就是创建线程对象。
4. 调用start方法，开启线程并让线程执行，同时还会告诉JVM去调用run方法。

//  测试类
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程！"+i);
}
}
}

// 自定义线程类
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}

线程对象调用 run方法和调用start方法区别:

• 线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让 JVM调用run方法在开启的线程中执行。

---

6、继承Thread类原理

因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？

Thread t1 = new Thread();
t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个
run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代
码。

• 创建线程是为了建立程序单独的执行路径，让多部份代码实现同时执行，也就是说线程创建并执行需要给定线程要执行的任务。
• 对于主线程，它的任务定义在main函数中，自定义线程需要执行的任务都定义在run方法中
• Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread 类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

---

7、多线程的内存图解

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进 行方法的压栈和弹栈。

 当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束 了，那么进程就结束了。

---

8、获取线程名称

String

getName() 返回此线程的名称。

static Thread

currentThread() 返回当前正在执行的线程对象的引用。

• Thread.currentThread() ：获取当前线程对象
• Thread.currentThread().getName(); ：获取当前线程对象的名称 

class MyThread extends Thread { //继承Thread
MyThread(String name){
super(name);
}
//复写其中的run方法
public void run(){
for (int i=1;i<=20 ;i++ ){
System.out.println(Thread.currentThread().getName()+",i="+i);
}
}
}
class ThreadDemo {
public static void main(String[] args) {
//创建两个线程任务
MyThread d = new MyThread();
MyThread d2 = new MyThread();
d.run();//没有开启新线程, 在主线程调用run方法
d2.start();//开启一个新线程，新线程调用run方法
}
}

通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时， 数字顺延。如Thread-1......

进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。

---

9、创建线程方式——实现Runnable接口

• 创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后 创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。
• Runnable接口用来指定每个线程要执行的任务。包含了 一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

•  接口中方法

void	run() 当一个对象实现的接口 Runnable是用来创建一个线程，启动线程使对象的 run方法在单独执行的线程调用。

• Thread类构造方法

Thread() 分配一个新的 Thread对象。

Thread(Runnable target) 分配一个新的 Thread对象。

Thread(Runnable target, String name) 分配一个新的 Thread对象。

Thread(String name) 分配一个新的 Thread对象。

创建线程的步骤：

1. 定义类实现Runnable接口。
2. 覆盖接口中的run方法。
3. 创建Thread类的对象。
4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5. 调用Thread类的start方法开启线程。

public class Demo02 {
public static void main(String[] args) {
//创建线程执行目标类对象
Runnable runn = new MyRunnable();
//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread thread = new Thread(runn);
Thread thread2 = new Thread(runn);
//开启线程
thread.start();
thread2.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程：正在执行！"+i);
}
}
}

public class MyRunnable implements Runnable{
//定义线程要执行的run方法逻辑
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我的线程：正在执行！"+i);
}
}
}

---

10、实现Runnable的原理

• 实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的 run方法，将线程任务代码定义到run方法中。
• 创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装 到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这 个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行 的线程的任务。

---

11、实现Runnable的好处

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable 接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。 继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线 程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型 就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

---

12、线程的匿名内部类使用

方式1：创建线程对象时，直接重写Thread类中的run方法。

new Thread() {
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
+ "...X...." + x);
}
}
}.start();

方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法。

public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
+ "...X...." + x);
}
}
};
new Thread(r).start();