Java多线程-----Thread类的基本用法，线程的状态及其转化 ✧*(ˊᗜˋ*) ✧*

Java多线程-----Thread类的基本用法，线程的状态及其转化 ✧(ˊᗜˋ) ✧*

IYF.星辰 2024-08-04 13:05:03 阅读 62

😖一.开启一个线程start()：

run()和start()的区别:

start()：用 start方法来启动线程，是真正实现了多线程，通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。

run()：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

①.通过start()启动线程：

<code>class MyThread2 extends Thread{

@Override

public void run() {

while(true){

System.out.println("what can I say");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class Demo4 {

public static void main(String[] args) throws InterruptedException {

MyThread2 t = new MyThread2();

//启动t线程

t.start();

//线程之间并发执行，主线程继续往下执行代码

while(true){

System.out.println("Mamba Out");

Thread.sleep(1000);

}

}

}

运行结果（start是真正启动一个线程，所以两个线程并发执行）：

②.通过类来调用run（）方法：

<code>class MyThread2 extends Thread{

@Override

public void run() {

while(true){

System.out.println("what can I say");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class Demo4 {

public static void main(String[] args) throws InterruptedException {

MyThread2 t = new MyThread2();

//通过类的实例来调用run()方法

t.run();

//线程之间并发执行，主线程继续往下执行代码

while(true){

System.out.println("Mamba Out");

Thread.sleep(1000);

}

}

}

运行结果（可以看到这其实就是调用一个普通的方法）：

run() 和 start()的区别理解二：

1、线程中的start()方法和run()方法的主要区别在于，当程序调用start()方法，将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话，会直接在当前线程中执行run()中的代码，注意，这里不会创建新线程。这样run()就像一个普通方法一样。

2、另外当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。但是可以重复调用run()方法。

总结起来就是run()就是一个普通的方法，而start()会创建一个新线程去执行run()的代码。

总结来说就是：

1、start方法用来启动相应的线程；

2、run方法只是thread的一个普通方法，在主线程里执行；

3、需要并行处理的代码放在run方法中，start方法启动线程后自动调用run方法；

4、run方法必须是public的访问权限，返回类型为void。

如果直接调用线程类的run()方法，这会被当做一个普通的函数调用，程序中仍然只有主线程这一个线程，也就是说，start()方法能够异步地调用run()方法，但是直接调用run()方法却是同步的，因此也就无法达到多线程的目的。

<code>只有通过调用线程类的start()方法才能真正达到多线程的目的。

通过作用功能和运行结果的角度分析：

作用功能不同：

a.run 方法的作用时描述线程具体要执行的任务

b.start 方法的作用是真正去申请一个系统线程

运行结果不同：

a.run 方法是一个类的普通方法，主动调用和调用普通方法一样，会顺序执行一次；

b.start 方法调用执行后，start方法内部会调用Java本地方法（封装了对系统底层的调用）真正的启动一个线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段

start方法的执行一般是比较快的（创建线程，比较轻量），一旦start执行完毕后，新线程就会开始执行，调用start的线程，也会继续执行（main）。同时，调用start方法，不一定非得是main线程，任何的线程都可以创建其他线程。如果资源充裕，就可以任意的创建线程（线程也不是越多越好，同时，值得注意的是，由于线程的创建是有开销的，当主线程中还有要执行的代码时，一般是主线程的代码先执行（这个创建线程的时间是很短的）一部分。

😋二.线程的终止：

1.使⽤⾃定义的变量来作为标志位:

public class demo1 {

private static boolean isQuit = false;

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

while(!isQuit){

System.out.println("hello thread");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("t 线程结束");

});

t.start();

Thread.sleep(2000);

//修改isQuit 变量，就能够影响到t 线程的结束了

System.out.println("main线程尝试终止t线程");

isQuit = true;

}

运行结果：

2.Thread.currentThread().isInterrupted() 代替⾃定义标志位

<code>public class demo3 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

//t.isInterrupted();

while(!Thread.currentThread().isInterrupted()){

System.out.println("hello thread");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

//throw new RuntimeException(e);

System.out.println("执行到catch操作");

}

});

//开启线程

t.start();

Thread.sleep(3000);

System.out.println("尝试终止线程");

t.interrupt();

}

运行结果：

小结一下就是：①.Interrupt方法能够设置标志位,也能够唤醒sleep等阻塞方法

②.sleep被唤醒后，又能清空标志位

🧐三.线程的休眠（sleep）:

这是我们⽐较熟悉⼀组⽅法，有⼀点要记得，因为线程的调度是不可控的，所以，这个⽅法只能保证实际休眠时间是⼤于等于参数设置的休眠时间的。

常用方法：

<code>public class Demo4 {

public static void main(String[] args) throws InterruptedException {

System.out.println(System.currentTimeMillis());

Thread.sleep(1000);

System.out.println(System.currentTimeMillis());

}

运行结果：

😀四.线程的等待join():

有时，我们需要等待⼀个线程完成它的⼯作后，才能进⾏⾃⼰的下⼀步⼯作

常用方法：

<code>public class Demo4 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

for(int i = 0;i < 3;i++){

System.out.println("Hello World~~");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

//开启t线程并让主线程等待t线程结束

t.start();

t.join();

for(int i = 0;i < 3;i++){

System.out.println("I am main Thread");

}

运行结果：

谁调用，谁就是被等待的，在哪里中调用，就是再哪里等待。这里再主线程中调用t.join(),所以是主线程等待t线程结束，而t线程是被等待的。可以看到直到t线程执行完成后，主线程才结束

练习一：

给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.实现代码, 能够创建两个线程, 对这个数组的所有元素求和.其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.最终再汇总两个和, 进行相加记录程序的执行时间.

代码详解：

<code>import java.util.*;

public class Demo1 {

public static long sum1 = 0L;

public static long sum2 = 0L;

public static void main(String[] args) throws IOException, InterruptedException {

long startTime = System.currentTimeMillis();//记录运行的起始时间

int[] nums = new int[10000000];

Random random = new Random();

for(int i = 0;i < nums.length;i++){

nums[i] = (random.nextInt(100) + 1);//1 ~ 100

}

//创建线程

Thread t1 = new Thread(()->{

for(int i = 0;i < nums.length;i += 2){

sum1 += nums[i];

}

System.out.println("线程t1，偶数下标的总和是：" + sum1);

});

Thread t2 = new Thread(()->{

for(int i = 1;i < nums.length;i += 2){

sum2 += nums[i];

}

System.out.println("线程t2，奇数下标的总和是：" + sum2);

});

//开启线程

t1.start();

t1.join();

t2.start();

t2.join();

long endTime = System.currentTimeMillis();//记录运行的终止时间

System.out.println("这1000w个随机数的和是: " + (sum1 + sum2));

System.out.println("一共的运行时间是: " + (endTime - startTime));

}

运行结果：

练习二：

有20个线程，需要同时启动。

每个线程按0-19的序号打印，如第一个线程需要打印0

请设计代码，在main主线程中，等待所有子线程执行完后，再打印 ok

代码详解：

<code>public class Demo5 {

public static void main(String[] args) throws InterruptedException {

Thread[] threads = new Thread[20];

for(int i=0; i<20; i++){

final int n = i;

threads[i] = new Thread(new Runnable() {

@Override

public void run() {//内部类使用外部的变量，必须是final修饰

System.out.println(n);

}

});

}

for(Thread t : threads){

t.start();

}

for(Thread t : threads){//同时执行20个线程，再等待所有线程执行完毕

t.join();

}

System.out.println("OK");

}

运行结果（结果1~19，这里只展示部分,线程并发执行，抢占到CPU的运行权时期不同，造成的随机打印的结果）：

😚五.获取一个线程的实例：

常用方法：

<code>public class Demo4 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

//获取当前线程的实例

Thread cur = Thread.currentThread();

for(int i = 0;i < 3;i++){

System.out.println(cur.getName()+" :Hello World~~");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

t.setName("线程一");

//开启t线程并让主线程等待t线程结束

t.start();

}

运行结果：

😆程的六个状态：

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。阻塞(BLOCKED)：表示线程阻塞于锁。等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。终止(TERMINATED)：表示该线程已经执行完毕。

线程状态之间的转化：