Java 多线程 实现方式 线程的生命周期

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量187 收藏
点赞数
分类专栏： Other 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014176737/article/details/115110415
版权

目录

1. 线程的实现方式

1.1 实现 Runnable 接口，重写 run 方法，无返回值

1.2 实现 Callable 接口，重新 call 方法，有返回值

1.3 继承 Thread 类，重写 run 方法，无返回值

2. 线程的生命周期

2.1 线程状态：new

2.2 线程状态：runnable

2.3 线程状态：blocked

2.4 线程状态：waiting

2.5 线程状态：timed waiting

2.6 线程状态：terminated

3. 总结

 

每一段代码，都是可以单独执行的，可以放到本地，查看一下执行效果。

千篇一律的看，不如自己动手实践一下，让咱们靠着理解，去加深记忆。

1. 线程的实现方式

线程的的实现方式分为三种。

1.1 实现 Runnable 接口，重写 run 方法，无返回值

1.2 实现 Callable 接口，重新 call 方法，有返回值

1.3 继承 Thread 类，重写 run 方法，无返回值

前两种是创建了一个可执行任务，直接调用 run 方法、call 方法，并不是以多线程的方式进行执行的。只有通过 Thread 类的 star 方法，启动的，才是以多线程的方式进行执行的。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

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

        long start = System.currentTimeMillis();
        System.out.println("主线程 开始");

        System.out.println("1. Runnable 测试代码");
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable " + Thread.currentThread().getName() + "：runing...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Runnable " + Thread.currentThread().getName() + "：over...");
            }
        };
        new Thread(runnable).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("");
        System.out.println("2. Callable 测试代码");
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("Callable " + Thread.currentThread().getName() + "：runing...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Callable " + Thread.currentThread().getName() + "：返回值，娃哈哈...");
                return "娃哈哈";
            }
        };
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println("callable方式 返回值：" + futureTask.get());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("");
        System.out.println("3. 继承 Thread 重写 run 方法");
        MyThread myThread = new MyThread();
        myThread.start();

        System.out.println("主线程 结束，耗时 " + (System.currentTimeMillis() - start));
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承 Thread " + Thread.currentThread().getName() + "：runing...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("继承 Thread " + Thread.currentThread().getName() + "：over...");
    }
}

2. 线程的生命周期

线程的生命周期可以整体可以涵盖为 4 种流程，分别是，新建、就绪、阻塞、终止。

这 4 种流程对应了 6 种状态。

新建：new

就绪：runnable

阻塞：blocked、waiting、timed waiting

终止：terminated

2.1 线程状态：new

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程A");
        System.out.println("[ " + thread.getName() + " ] 的状态是：" + thread.getState());
        //控制台输出： [ 线程A ] 的状态是：NEW
    }
}

2.2 线程状态：runnable

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        // 1. 声明一个线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + " runing... " + i);
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程A");

        // 2. 启动线程
        thread.start();

        // 3. 查看线程状态 [ 因为CPU执行顺序是不一定的，此时假设，启动后，执行了，主线程中，查看状态的代码 ]
        System.out.println("[ " + thread.getName() + " ] 的状态是：" + thread.getState());
        // 控制台输出：
        // [ 线程A ] 的状态是：RUNNABLE
        // 线程A runing... 0
        // ......
        // 线程A runing... 9
    }
}

2.3 线程状态：blocked

import sun.misc.Lock;

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        // 1. 生命锁对象
        Lock lock = new Lock();

        // 2. 声明两个线程
        MyThread threadA = new MyThread(lock, "线程A");
        MyThread threadB = new MyThread(lock, "线程B");
        threadA.start();
        threadB.start();
        try {
                Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 3. 查看状态
        System.out.println("[ " + threadA.getName() + " ] 的状态是：" + threadA.getState());
        System.out.println("[ " + threadB.getName() + " ] 的状态是：" + threadB.getState());
    }
}

class MyThread extends Thread {
    private Lock lock = null;

    public MyThread(Lock lock, String name) {
        this.lock = lock;
        super.setName(name);
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：runing...");
        try {
            System.out.println(Thread.currentThread().getName() + "：runing...开始争夺锁");
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "：runing...拿到了锁");
                System.out.println(Thread.currentThread().getName() + "：runing...模拟业务执行...");
                Thread.sleep(1000);
            }
            System.out.println(Thread.currentThread().getName() + "：over...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

2.4 线程状态：waiting

import sun.misc.Lock;

public class ThreadTest {
    public static void main(String[] args) throws Exception {
        // 1. 生命锁对象
        Lock lock = new Lock();

        // 2. 声明两个线程
        MyThread threadA = new MyThread(lock, "线程A");
        MyThread threadB = new MyThread(lock, "线程B");
        threadA.start();
        threadB.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 3. 第一次查看状态
        System.out.println("[ " + threadA.getName() + " ] 的状态是：" + threadA.getState());
        System.out.println("[ " + threadB.getName() + " ] 的状态是：" + threadB.getState());


        try {
            Thread.sleep(3000);
            synchronized (lock) {
                lock.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 4. 第二次查看状态
        System.out.println("[ " + threadA.getName() + " ] 的状态是：" + threadA.getState());
        System.out.println("[ " + threadB.getName() + " ] 的状态是：" + threadB.getState());
    }
}

class MyThread extends Thread {
    private Lock lock = null;

    public MyThread(Lock lock, String name) {
        this.lock = lock;
        super.setName(name);
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：runing...");
        try {
            System.out.println(Thread.currentThread().getName() + "：runing...开始争夺锁");
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "：runing...拿到了锁");
                System.out.println(Thread.currentThread().getName() + "：runing...模拟业务执行...");
                lock.wait();
                System.out.println(Thread.currentThread().getName() + "：runing...模拟业务执行...2");
            }
            System.out.println(Thread.currentThread().getName() + "：over...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

2.5 线程状态：timed waiting



public class ThreadTest {
    public static void main(String[] args) throws Exception {
        // 1. 声明线程
        MyThread threadA = new MyThread();
        threadA.setName("线程A");
        threadA.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 2. 查看状态
        System.out.println("[ " + threadA.getName() + " ] 的状态是：" + threadA.getState());

        // 控制台输出
        // 线程A：runing...
        // [ 线程A ] 的状态是：TIMED_WAITING
        // 线程A：over...
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：runing...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "：over...");
    }
}

2.6 线程状态：terminated



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

        // 1. 声明两个线程
        MyThread threadA = new MyThread();
        threadA.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 3. 第一次查看状态
        System.out.println("[ " + threadA.getName() + " ] 的状态是：" + threadA.getState());
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "：runing...");
        System.out.println(Thread.currentThread().getName() + "：runing...开始争夺锁");
        System.out.println(Thread.currentThread().getName() + "：runing...拿到了锁");
        System.out.println(Thread.currentThread().getName() + "：runing...模拟业务执行...");
        System.out.println(Thread.currentThread().getName() + "：runing...模拟业务执行...2");
        System.out.println(Thread.currentThread().getName() + "：over...");
    }
}

3. 总结

线程的生命周期分为四种， 新建、就绪、阻塞、终止，对应六种状态，

       新建：new，

       就绪：runnable，

       阻塞：blocked、waiting、timed waiting，

       终止：terminated。

当线程被创建出来以后，对应的是new，随后通过start()方法启动对应runnable，cpu切片时间执行完成，但是业务没有走完，线程回归到runable状态，当在cpu切片时间内执行完毕，线程进入terminated 终止状态，线程生命周期结束。
在线程执行过程中，调用sleep、wait 传入时间，随后线程进入阻塞状态中的 timed waiting 定时等待状态，待指定时间过后，线程进入runnable 就绪状态，等待cpu调用。
在线程执行过程中，调用 wait 方法，不传入时间、线程进入到 waiting 等地状态，待外部调用 notify 或 notifyAll 方法通知线程进入到 runable 就绪状态。
在A线程执行过程中，调用B线程的 join 方法后，在B线程执行完毕之前，A线程进入到 waiting 等地状态，等待B线程执行完毕后，自动通知A线程进入到 runable 就绪状态。
线程A、线程B，在争夺锁的过程，假如A先拿到锁，B就会进入到blocked，阻塞状态，等待A释放锁后，自己再去拿锁。

 

致谢

https://zhuanlan.zhihu.com/p/58966050
https://www.bilibili.com/video/BV1k74118721?t=513&p=24
https://blog.csdn.net/maoshaomiao/article/details/90756576

Pd_1503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程的生命周期
qq_30155803的博客
10-19 1818
1、线程的生命周期（状态） （1）线程一共有6种状态分别为： New:新创建状态，当new一个Thread对象，但未调用start方法后就处于该状态 Runnable:可运行状态，可运行状态实际上分为两种状态一种时Running(正在运行)，另 一种是Ready（已准备）,这两种状态统称为可运行状态，当线程的start方法被调用后 就会处于reedy状态，此时线程会等待分配CPU时间片，当获取到时间片之后就处于 running状态，同理当时间片用完（系统调度，或调用了yield方法）之后就又回到了re
Java多线程实现方式及生命周期
Jiang216的博客
06-13 161
Java中线程的实现方式 1.实现Runnable接口 class MyThread implements Runnable{ private String name ; // 表示线程的名称 public MyThread(String name){ this.name = name ; // 通过构造方法配置name属性 } public void run(){ // 覆写run()方法，作为线程
线程的五大生命周期
Jarvis.y的博客
11-02 973
线程在创建并启动这一系列操作会经历五大生命周期 分别为：新建（NEW），就绪（Runnable），运行（Running），阻塞（Blocked），死亡（Dead） 当线程被启动后，它不可能一直使用CPU独自运行，还有更多的线程需要使用到CPU，所以CPU会在多条线程之间切换执行命令，于是线程状态也会多次在运行，阻塞之间切换。 线程运行生命周期图 新建状态 （NEW） 当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值。 Thread
说说线程的生命周期
学一次的博客
05-01 2989
线程的生命周期分为创建（new）、就绪（Runnable）、运行（running）、阻塞（Blocked）、死亡（Dead）五种状态。
JAVA基础高级复习(七)生命周期图_线程池_Callable方法
looperjustice的博客
09-15 87
用start就会以多线程的方式来调用run方法； start会调用整个类下面的run方法，多个类同时执行 那个new的那个 就是多个人访问的时候 就new一个线程的对象，调用star，调用对象所写的run方法； thread构造器里面 要放实现类实现run； ...
Java 多线程生命周期
烟雨gps
02-28 277
多线程生命周期 文章目录多线程生命周期1、五个阶段1.1 新建1.2 就绪1.3 运行1.4 阻塞1.5 死亡 1、五个阶段 线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。其之间的转换关系如下图 1.1 新建 当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没...
Java多线程-线程的生命周期
01-27
Java多线程中，线程的生命周期是编程中必须理解的重要概念。在JDK1.5之前，线程被划分为五个状态，分别是新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。在JDK1.5及之后，线程的...
java多线程编程之线程的生命周期
09-04
Java多线程编程中，线程的生命周期包括四个主要阶段：新建、运行、阻塞和终止。理解这些状态以及如何通过Thread类中的方法控制它们至关重要。 1. **新建**： 当通过`new Thread()`创建一个新的线程对象时，线程...
详解三种java实现多线程的方式
09-03
随着数据时代的发展，对高效并发处理的需求不断增加，理解并掌握Java中的多线程实现方式变得至关重要。本文将详细介绍Java中实现多线程的三种主要方法：继承Thread类、实现Runnable接口以及使用ExecutorService。 1...
Java 线程的生命周期完整实例分析
08-25
Java 中的线程生命周期主要包括以下几个阶段：新建（New）、可运行（Runnable）、运行（Running）、等待（Waiting）、阻塞（Blocked）、死亡（Dead）。在 Java 中，我们可以通过使用 Thread 的生命周期来实现多线程...
图解Java线程的生命周期
09-04
正确管理线程生命周期是防止死锁、资源浪费和提高程序效率的关键。合理设计线程间的协作，使用线程池来控制线程数量，以及正确处理异常，都是编写多线程程序时应考虑的重要因素。理解并掌握Java线程的生命周期转换有...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
Java多线程：理解线程生命周期与状态
线程状态—线程的生命周期是Java多线程编程中的重要概念，它涉及到线程从创建到消亡的动态行为。在Java中，每个线程都处于四种不同的状态：就绪、运行、阻塞和消亡。理解这些状态有助于程序员更好地管理线程的并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值