【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)

113 阅读 0 评论 75 点赞

我是靠谱客的博主大方荷花，最近开发中收集的这篇文章主要介绍【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

一、线程与进程
二、并发与并行
三、线程调度
四、创建线程
- 4.1 Thread类
- 4.2 Runnable接口
五、Thread和Runnable的区别
六、Thread类常用方法
- 构造方法
- 常用方法
- 优先级相关的方法
七、线程中断
八、线程插队
九、用户线程和守护线程
十、线程的生命周期(状态)
- 10.1 阻塞(Blocaked)
- - 计时等待 TimedWaiting
  - 锁阻塞 BLOCKED
  - 无限等待 Waiting
  - 线程的等待唤醒机制
- 10.2 线程优先级

一、线程与进程

进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程： 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

二、并发与并行

并发： 指两个或多个事件在同一个时间段内发生。
并行： 指两个或多个事件在同一时刻发生（同时发生）。

并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，分时交替运行的时间是非常短的。

在多个 CPU 系统中，这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

单核处理器的计算机是不能并行的处理多个任务的，只能多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，这种情况称之为线程调度。

Java代码获取当前电脑CPU个数：

Runtime runtime = Runtime.getRuntime();
int cpuNums = runtime.availableProcessors();

三、线程调度

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

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。此时，这些程序是在同时运行，“感觉这些软件好像在同一时刻运行着”，实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

四、创建线程

多线程执行时，在栈内存中，每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
在这里插入图片描述

创建线程有两种方式：

创建一个Thread类，或者一个Thread子类的对象
创建一个实现Runnable接口的类的对象

4.1 Thread类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须 Thread 类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

快速入门：

通过继承Thread类创建并启动多线程：

① 定义 Thread 类的子类，并重写该类的run()方法
② 创建Thread子类的实例，即创建了线程对象
③ 调用线程对象的 start() 方法来启动该线程

Thread类中的run()方法实现了Runnable接口中的run()方法。

// 测试类
public class ThreadTest {
	public static void main(String[] args) {  
        // 创建自定义线程对象  
        Cat cat = new Cat();  
        // 启动线程
        // 调用start方法会自动创建一个线程并调用run方法
        cat.start(); 
    }  
}

// 1. 当一个类继承了Thread类，该类就可以作为线程使用
class Cat extends Thread {
	
	// 2. 重写run方法，里面是自己的业务代码
	@Override
	public void run() {
		// 3. 业务代码
		for(int i = 0; i < 20; i++) {
			System.out.println("我是小猫咪，喵喵喵");
			
			try{
				// 输出完后当前线程休眠1秒再执行
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
}

start底层：

当调用start方法时，start方法会调用start0方法，而start0方法是本地方法，由JVM调用，底层是C/C++实现

在这里插入图片描述

4.2 Runnable接口

java.lang.Runnable是Java中用以实现线程的接口，只需要重写run方法即可。任何实现线程功能的类都必须实现此接口。

Java不支持多继承，如果继承了其他类则无法继承Thread类，则需要实现Runnable接口。如果不打算重写Thread类的其他方法，也可以选择实现Runnable接口。

快速入门：

通过实现Runnable接口创建并启动多线程：

① 定义 Runnable 接口的实现类，并重写该接口的 run() 方法
② 创建Runnable实现类的实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
③ 调用线程对象的 start() 方法来启动线程

// 测试类
public class ThreadTest {
	public static void main(String[] args) {  
        // 创建自定义的线程任务对象  
        Dog dog = new Dog();  
        // 创建线程对象，并把线程任务对象传入
        Thread thread = new Thread(dog);
        // 启动线程
        // 调用start方法会自动创建一个线程并调用run方法
        thread.start(); 
    }  
}

// 1. 创建类实现Runnable接口
class Dog implements Runnable {  
	// 2. 重写run方法，该方法体就是业务逻辑代码
    @Override  
    public void run() {  
        for (int i = 0; i < 20; i++) {  
            System.out.println("小狗汪汪汪");  
            
			try{
				// 输出完后当前线程休眠1秒再执行
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
        }
    }  
}

五、Thread和Runnable的区别

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

六、Thread类常用方法

构造方法

Thread()：创建一个线程对象
Thread(String name)：创建一个指定名字的线程对象

Thread(Runnable target)：创建基于Runnable接口实现类的一个带有指定目标线程对象
Thread(Runnable target,String name)：创建基于Runnable接口实现类的一个带有指定目标线程对象并指定名字

常用方法

String getName()：获取当前线程名称

void start()：启动线程，Java虚拟机调用此线程的run方法，一个线程对象同时只能启动一次

void run()：线程要执行的任务在此方法中定义，一般需要重写，方法体就代表了线程需要完成的任务，因此run()方法被称为线程执行体

static void sleep(long millis)：使当前正在执行的线程以指定的毫秒值休眠（暂时停止执行）

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

void join()：线程插队，一旦插队成功，优先执行调用join()方法的线程，执行结束后才执行其他线程。
void join(long millis)：为优先执行调用join()方法的线程，等待该线程终止的最长时间millis毫秒

void interrupt()：中断线程，没有真正的结束线程，一般用于中断正在休眠的线程

static void yield()：线程的礼让，让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。

优先级相关的方法

int getPriority()：获取线程优先级

void setPriority(int newPriority)：设置线程优先级

七、线程中断

场景：线程休眠时使用

代码演示：

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

        T t = new T();
        Thread thread = new Thread(t);
        thread.setName("吃东西线程");

        // 开启线程
        thread.start();

        for (int i = 0; i < 3; i++) {
            System.out.println("主线程的逻辑代码....");
            Thread.sleep(1000);
        }

        // 开启线程后，执行五次吃东西会进入20秒的休眠，在此期间，调用interrupt方法中断线程
        // 然后该线程就会抛出InterruptedException，而我们使用catch捕获了该异常
        // 从而执行catch中的代码
        System.out.println("中断" + thread.getName());
        thread.interrupt();
    }
}

class T implements Runnable {
    @Override
    public void run() {
        int a = 0;
        while (a < 50) {
            System.out.println("吃东西..." + a++);
            if (a % 5 == 0) {
                try {
                    // 当吃东西执行五次后，休眠20秒
                    System.out.println("开始休眠，休眠中...");
                    Thread.sleep(20000);
                    System.out.println("休眠结束...");
                } catch (InterruptedException e) {
                    // 当该线程执行到interrupt方法时，会抛出一个InterruptedException异常
                    // 可以在捕获到该异常时，加入业务代码，处理逻辑
                    System.out.println(Thread.currentThread().getName() + "在休眠的时候被中断了....");
                }
            }
        }

    }
}

执行上面程序，得到一下结果。

可以看到，吃东西线程在第一次休眠的时候，被唤醒没有执行“休眠结束”语句，因为是在中断时抛出了异常，直接执行catch块中的代码，而此时的中断，直接中断了20秒的睡眠。
可以理解为，让该线程中断一下，然后继续执行该线程的代码。
因为睡眠20秒的那行代码已经执行过了，再加上中断sleep方法会抛出异常，所以直接进入catch块中的代码，如果没有sleep20秒而中断的话，则不会抛出异常，而是中断后，继续执行下面代码。

中断方法还可以配合重新设置优先级来使用，比如该线程之前的优先级是10，在主线程重新设置该线程的优先级后，中断一下。

在这里插入图片描述

八、线程插队

场景：
当主线程的i == 3的时候，优先执行子线程，子线程执行完毕后，再执行主线程。

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

        T t = new T();
        Thread thread = new Thread(t);

        // 开启线程
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程的吃东西...." + i);
            Thread.sleep(1000);
            if (i == 3) {
                // 让子线程先执行，执行完毕后再执行当前线程
                thread.join();
            }
        }
    }
}

class T implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程的吃东西...." + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看到，结果符合预期
在这里插入图片描述

九、用户线程和守护线程

用户线程： 也叫工作线程，当线程的任务执行完或通知方式结束

守护线程： 一般为工作线程服务的，当所有的用户线程结束，守护线程自动结束。

常见的守护线程：垃圾回收机制

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

场景：
设置守护线程。

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

        T t = new T();
        Thread thread = new Thread(t);

        // 设置为守护线程，这样，主线程结束后，守护线程也就结束了
        thread.setDaemon(true);

        // 开启线程，先设置，后开启
        thread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程的吃东西...." + i);
            Thread.sleep(1000);
        }
    }
}

class T implements Runnable {
    @Override
    public void run() {
        // 死循环，如果不设置为守护线程，该循环不会停下
        for (; ; ) {
            System.out.println("子线程的吃东西....");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看到，主线程结束后，子线程哪怕是死循环，也会结束
在这里插入图片描述

十、线程的生命周期(状态)

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。

新建(New)
可运行(Runnable)
正在运行(Running)
阻塞(Blocaked)
终止(Dead)

在这里插入图片描述

在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动。还没调用start方法。
Runnable（可运行）	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。而在该状态，可以在内核中分为`Ready`(就绪)和`Running`(运行)状态
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting（无限等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

10.1 阻塞(Blocaked)

计时等待 TimedWaiting

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

static void sleep(long millis)：使当前正在执行的线程以指定的毫秒值休眠（暂时停止执行）

在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当调用sleep方法之后，当前执行的线程就进入到“休眠状态”，就是Timed Waiting（计时等待）。

在这里插入图片描述

① 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
② 为了让其他线程有机会执行，可以将 Thread.sleep() 的调用放线程 run() 之内。这样才能保证该线程执行过程中会睡眠。
③ sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
④ sleep()中指定的时间是线程不会运行的最短时间。sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

锁阻塞 BLOCKED

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。这是由Runnable状态进入Blocked状态。

在这里插入图片描述

无限等待 Waiting

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

一个调用了某个对象的Object.wait()方法的线程会等待另一个线程调用此对象的Object.notify()方法或Object.notifyAll()方法。

waiting状态不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。

在这里插入图片描述

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行） 状态中调用了wait()方法那么A线程就进入了 Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify() 方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行） 状态；如果没有获取锁对象，那么就进入到 Blocked（锁阻塞状态）。

线程的等待唤醒机制

在这里插入图片描述

在翻阅API的时候发现 Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系是很紧密的。

比如，Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于生活中的小闹钟，设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了。如果没有得到（唤醒）通知，线程就处于Timed Waiting状态，直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，线程从Timed Waiting状态立刻唤醒。

10.2 线程优先级

Java为线程类提供了10个优先级，优先级可以用整数1-10表示，超过范围会抛出异常，主线程默认优先级为5，也可以使用优先级常量设置优先级

优先级常量： java.lang.thread

MAX_PRIORITY：线程的最高优先级10
MIN_PRIORITY：线程的最低优先级1
NORM_PRIORITY：线程的默认优先级5

优先级相关的方法： java.lang.thread

int getPriority()：获取线程优先级
void setPriority(int newPriority)：设置线程优先级

public class MyThreadPriority {

    public static void main(String[] args) {
        int mainPriority = Thread.currentThread().getPriority();
        System.out.println("主线程优先级为" + mainPriority);

        MyThread03 mt1 = new MyThread03("线程1");
        // mt1.setPriority(10);
        mt1.setPriority(Thread.MAX_PRIORITY);
        mt1.start();
        System.out.println("线程1的优先级为"+ mt1.getPriority());
    }
}

class MyThread03 extends Thread {
    private String name;

    public MyThread03(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("线程" + name + "正在运行第" + i + "次");
        }
    }
}

最后

以上就是大方荷花为你收集整理的【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)的全部内容，希望文章能够帮你解决【Java多线程】创建线程、线程的生命周期——Thread类和Runnable接口一、线程与进程二、并发与并行三、线程调度四、创建线程五、Thread和Runnable的区别六、Thread类常用方法七、线程中断八、线程插队九、用户线程和守护线程十、线程的生命周期(状态)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：JavaSE
浏览次数：113 次浏览
发布日期：2023-10-25 01:26:24
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_22_f2_14_jg0.html

概述

文章目录

一、线程与进程

二、并发与并行

三、线程调度

四、创建线程

4.1 Thread类

4.2 Runnable接口

五、Thread和Runnable的区别

六、Thread类常用方法

构造方法

常用方法

优先级相关的方法

七、线程中断

八、线程插队

九、用户线程和守护线程

十、线程的生命周期(状态)

10.1 阻塞(Blocaked)

计时等待 TimedWaiting

锁阻塞 BLOCKED

无限等待 Waiting

线程的等待唤醒机制

10.2 线程优先级

最后

评论列表共有 0 条评论

发表评论取消回复

概述

文章目录

一、线程与进程

二、并发与并行

三、线程调度

四、创建线程

4.1 Thread类

4.2 Runnable接口

五、Thread和Runnable的区别

六、Thread类常用方法

构造方法

常用方法

优先级相关的方法

七、线程中断

八、线程插队

九、用户线程和守护线程

十、线程的生命周期(状态)

10.1 阻塞(Blocaked)

计时等待 TimedWaiting

锁阻塞 BLOCKED

无限等待 Waiting

线程的等待唤醒机制

10.2 线程优先级

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复