线程——通过 Thread 类或 Runnable 接口开启线程

最新推荐文章于 2024-08-15 10:36:17 发布
最新推荐文章于 2024-08-15 10:36:17 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： thread 文章标签： thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43575044/article/details/120473481
版权

Runnable 和 Thread

Thread 类实现了 Runnable 接口，
run() 方法是 Runnable 接口中的抽象方法
在这里插入图片描述

线程相关概念

  1. 单线程：同一个时刻，只允许执行一个线程

  2. 多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

  3. 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核 cpu 实现的多任务就是并发。
    在这里插入图片描述

  4. 并行：同一个时刻，多个任务同时执行。多核 cpu 可以实现并行。并发和并行可以同时实现。

在这里插入图片描述

通过Java代码获取当前电脑的 cpu 数量



package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 16:26 2021/9/25
 */
public class CpuNums {
    public static void main(String[] args) {

        Runtime runtime = Runtime.getRuntime();
        // 获取当前电脑的 cpu 数量
        int cpuNums = runtime.availableProcessors();
        System.out.println("cpuNums = " + cpuNums);

    }
}

在这里插入图片描述

线程基本使用

在 java 中线程来使用有两种方法：

  1. 继承 Thread 类，重写 run 方法
  2. 实现 Runnable 接口，重写 run 方法

继承 Thread 类

请编写程序开启一个线程，该线程每隔1秒。在控制台输出“GinSherry”
对上题改进：当输出 10 次后，结束该线程



package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 17:04 2021/9/25
 */
public class Thread01 {
    public static void main(String[] args) {

        // 创建 Cat 对象，当作线程使用
        Cat cat = new Cat();
        // 启动线程
        cat.start();

    }
}
// 1. 当一个类继承了 Thread 类，该类就可以当作线程使用
// 2. 我们会重写 run 方法，写上自己的业务代码
// 3. run 方法来自 Thread 实现的 Runnable 接口
//    Thread.java 中的 run 方法:
//    @Override
//    public void run() {
//        if (target != null) {
//            target.run();
//        }
//    }

class Cat extends Thread{

    int times = 0;

    @Override
    public void run() {
        while(true){
            // 每隔一秒输出 ”GinSherry“
            System.out.println("GinSherry" + ++times);
            // 让该线程休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 执行 10 次就停止
            if(times >= 10){
                break;
            }
        }
    }
}

多线程机制



package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 17:04 2021/9/25
 */
public class Thread01 {
    public static void main(String[] args) {

        // 创建 Cat 对象，当作线程使用
        Cat cat = new Cat();
        // 启动线程
        cat.start();
        // 说明：当主线程启动一个子线程 Thread-0 ，主线程不会阻塞，会继续执行
        // 这时，主线程和子线程是交替执行
        System.out.println("主线程继续执行，主线程名 = " + Thread.currentThread().getName());
        for (int i = 1; i <= 10; i++) {
            System.out.println("主线程 i = " + i);
            // 让主线程休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Cat extends Thread{

    int times = 0;

    @Override
    public void run() {
        while(true){
            // 每隔一秒输出 ”GinSherry“
            System.out.println("GinSherry 子线程名 = " + Thread.currentThread().getName() + " 次数 = " + ++times);
            // 让该线程休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 执行 10 次就停止
            if(times >= 10){
                break;
            }
        }
    }
}

在这里插入图片描述
在这里插入图片描述

为何要调用 cat.start()，而不直接调用 cat.run()



package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 17:04 2021/9/25
 */
public class Thread01 {
    public static void main(String[] args) {

        // 创建 Cat 对象，当作线程使用
        Cat cat = new Cat();
        // 启动线程
        // cat.start();

        // 如果不通过 cat.start 来执行 run 方法，而是直接调用 run 方法
        // 则 run 方法就是一个普通的方法，并不会真正启动一个线程，方法会阻塞，直到执行完 run 方法，才会继续向下执行
        // 可通过输出的子线程名来验证
        cat.run();

        // 说明：当主线程启动一个子线程 Thread-0 ，主线程不会阻塞，会继续执行
        // 这时，主线程和子线程是交替执行
        System.out.println("主线程继续执行，主线程名 = " + Thread.currentThread().getName());
        for (int i = 1; i <= 10; i++) {
            System.out.println("主线程 i = " + i);
            // 让主线程休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 1. 当一个类继承了 Thread 类，该类就可以当作线程使用
// 2. 我们会重写 run 方法，写上自己的业务代码
// 3. run 方法来自 Thread 实现的 Runnable 接口
//    Thread.java 中的 run 方法:
//    @Override
//    public void run() {
//        if (target != null) {
//            target.run();
//        }
//    }

class Cat extends Thread{

    int times = 0;

    @Override
    public void run() {
        while(true){
            // 每隔一秒输出 ”GinSherry“
            System.out.println("GinSherry 子线程名 = " + Thread.currentThread().getName() + " 次数 = " + ++times);
            // 让该线程休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 执行 10 次就停止
            if(times >= 10){
                break;
            }
        }
    }
}

在这里插入图片描述

start() 方法底层


		/*
            源码解读
            1.
            public synchronized void start() {
              start0();
            }
            2. start0() 是本地方法，是 JVM 机调用，底层是 c/c++ 实现
               真正实现多线程效果的是 start0()，而不是 run()
               start()方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于cpu，由cpu统一调度。
            private native void start0();
         */

在这里插入图片描述

实现 Runnable 接口


package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 19:57 2021/9/25
 */
public class Thread02 {
    public static void main(String[] args) {

        Dog dog = new Dog();
        Thread thread = new Thread(dog);
        thread.start();

    }
}
class Dog implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while(true){
            System.out.println("hi~~~ " + ++count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count >= 10){
                break;
            }
        }
    }
}

在这里插入图片描述

多个子线程案例



package thread_;

/**
 * @Author: Gin
 * @Description:
 * @Modified By: Gin
 * @Date: Created in 20:04 2021/9/25
 */
public class Thread03 {
    public static void main(String[] args) {

        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();

    }
}
class T1 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while(true){
            // 每隔 1 秒输出一次 Hello~~~~，输出 10 次就停止
            System.out.println("Hello~~~~" + ++count);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count >= 10){
                break;
            }
        }
    }
}
class T2 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while(true){
            // 每隔 0.5 秒输出一个 Hi~~~~，输出 5 次就停止
            System.out.println("Hi~~~~" + ++count);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count >= 5){
                break;
            }
        }
    }
}

继承 Thread 类和实现 Runnable 接口的区别

  1. 从 Java 的设计来看，通过继承 Thread 或者实现 Runnable 接口来创建线程本质上没有区别，从 jdk 帮助文档我们可以看到 Thread 类本身就实现了
    Runnable 接口
  2. 实现 Runnable 接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用 Runnable

通过实现 Runnable 接口，两个线程都运行 t3 的 run 方法：
在这里插入图片描述
但是继承 Thread 类，是通过类对象来启动子线程，一个线程对应一个对象，不能实现资源共享：
在这里插入图片描述

伊颦伊笑
关注
专栏目录
Java基础-Runnable启动线程的使用
二丫的博客
09-26 3777
Runnable启动线程的使用 实现线程的第二种方式： Runnable接口 Runnable 接口的实现类的线程 通过Thread类启动 需要把实现类对象传入Thread类的构造方法中 然后通过Thread的start方法启动该Runnable实现类的线程。 Runnable实现类线程 只需要创建一个对象 然后传入多个Thread类构造方法中，通过多个Thread对象去启动多个线程。 Runnable接口的优点： 可以避免由于Java单继承带来的局限性（不占继承名额） 适合多个相同程序的代码去处
Java开发笔记（九十七）利用Runnable启动线程
pinlantu的博客
05-11 543
前面介绍了线程的基本用法，按理说足够一般的场合使用了，只是每次开辟新线程，都得单独定义专门的线程类，着实开销不小。注意到新线程内部真正需要开发者重写的仅有run方法，其实就是一段代码块，分线程启动之后也单单执行该代码段而已。因而完全可以把这段代码抽出来，把它定义为类似方法的一串任务代码，这样能够像调用公共方法一样多次调用这段代码，也就无需另外定义新的线程类，只需命令已有的Thread去执行该代码段...
Java从入门到放弃26---线程的三种创建方式之实现Runnable接口
DOGIOOH的博客
06-03 2962
Java从入门到放弃26—线程的三种创建方式之实现Runnable接口 01 Runnable接口 Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread ...
Java并发编程：创建并启动java线程（Thread，Runnable，线程名称 ，暂停和停止线程）
最新发布
qq_33240556的博客
08-15 472
使用Thread类或实现Runnable接口是创建线程的两种常见方式。设置线程名称可以方便调试和跟踪。使用来暂停线程。不推荐直接停止线程，而是通过设置标志位来优雅地停止线程。通过这些方法，你可以在Java中有效地创建和管理多线程程序。需要注意的是，线程管理涉及到一些细节和潜在的问题，如线程安全、死锁等，因此在实际开发中需要特别注意这些问题。
Runnable 线程
qq_18532033的博客
05-01 962
/** * 创建线程方式二: * 1、创建：实现Runnable+重写run * 2、启动: 创建实现类对象 +Thread对象+ start * * 推荐: 避免单继承的局限性，优先使用接口 * 方便共享资源 * @author 裴新 QQ:3401997271 * */ public class StartRun implements Runnable{ /** * ...
java runnable 启动_Java开发笔记（九十七）利用Runnable启动线程
weixin_33019827的博客
02-13 571
前面介绍了线程的基本用法，按理说足够一般的场合使用了，只是每次开辟新线程，都得单独定义专门的线程类，着实开销不小。注意到新线程内部真正需要开发者重写的仅有run方法，其实就是一段代码块，分线程启动之后也单单执行该代码段而已。因而完全可以把这段代码抽出来，把它定义为类似方法的一串任务代码，这样能够像调用公共方法一样多次调用这段代码，也就无需另外定义新的线程类，只需命令已有的Thread去执行该代码段...
线程Runnable
hh_h_hhh_d的博客
01-07 404
Runnable接口中只有一个run()函数，并没有start()函数，所以它必须依托其他类来使用，比如Thread类 Thread中有个以Runnable为参数的构造函数   @FunctionalInterface public interface Runnable { /** * When an object implementing interface &lt;c...
多线程实现方式——继承 Thread 类和Runnable 接口及区别
Shawn的博客
02-23 643
方式一：继承Thread类，重写run()方法 一共有5张票，三个线程进行卖票 package cn.itcast.thread; //继承 Thread 类实现多线程 class MyThread extends Thread { private String title; private int ticket = 5; public MyThread(String title) {...
java Runnable接口创建线程
08-30
任何实现Runnable接口的类都可以被用来创建线程。 如何使用Runnable接口创建线程 使用Runnable接口创建线程的步骤如下： 1. 创建一个实现Runnable接口的类。 2. 在该类中重写run()方法，以便在线程中执行的操作。...
Java中继承thread类与实现Runnable接口的比较
08-30
在 Java 中，创建线程有两种方式：继承 Thread 类和实现 Runnable 接口。这些方式都可以用来创建线程，但它们之间有着一些关键的区别。 继承 Thread 类 继承 Thread 类是 Java 中创建线程的一种方式。这种方式下，...
java学习线程篇之多线程的实现方式：继承Thread类、实现Runnable接口或Callable接口~
TingtingYang
08-23 1198
java学习之线程篇~1. 基本概念：进程与线程2. 实现多线程的方式2.1 继承Thread类 1. 基本概念：进程与线程 在操作系统的定义中，进程是指一次程序的完整运行，这个运行的过程之中内存、处理器、IO等资源操作都要为这个进程进行服务。 Windows属于多进程的操作系统，那么问题就来了？每一个进程都需要资源的支持，那么这么多进程怎么分配资源呢？ 在同一个时间段上，会有多进程轮流去抢占资源...
java实现多线程的两种方式继承Thread类和实现Runnable接口的方法
09-01
在Java中，创建多线程有两种主要的方式：继承`Thread`类和实现`Runnable`接口。这两种方式都是为了实现程序的并发执行，即允许多个任务在同一时间片内交替执行。下面我们将详细讨论这两种方法及其区别。 ### 继承...
【JavaSE专栏77】线程的创建和启动，继承Thread类或实现Runnable接口完成线程创建启动
Designer 小郑的技术博客
08-15 1729
本文讲解了 Java 中线程的创建和启动的方式，并给出了样例代码。进程是指正在运行的一个程序的执行实例，它是操作系统进行资源分配和调度的基本单位，每个进程都有自己的内存空间、文件描述符、运行时环境等，进程之间是相互独立的，彼此之间不共享内存空间。
Java线程基础(5): 线程状态之 Runnable
mingyuli的博客
12-06 3732
在上一篇我们粗略谈到了 Java 的6种线程状态，并对其中较为简单的 NEW 和 TERMINATED 做了分析，现在我们具体来看下 State.RUNNABLE状态，即所谓的可运行状态。（以下简称 runnable） 再次强调，这里谈论的是Java虚拟机层面所暴露给我们的状态，与操作系统底层的线程状态是两个不同层面的事。 具体而言，这里说的 Java 线程状态均来自于 Thread 类下的 State 这一内部枚举类中所定义的状态： 什么是 RUNNABLE？ 直接看它的 Javadoc.
多线程 创建线程（Runnable）
LY_yhq
09-23 112
package thread; /** 创建线程方式二： 1.创建：继承Runnable+重写run 2.启动：创建子类对象+Thread对象+start 推荐：避免单继承的局限性，优先使用接口 方便共享资源 @author */ public class StartRun implements Runnable { /** * 线程入口点 */ @Override public vo...
java实现Runnable接口启动线程
dadajuan121的博客
07-21 331
java实现Runnable接口启动线程
实现Runnable接口，通过Thread启动多线程
F2Zf的博客
11-22 553
package com.xiner.demo;public class Demo implements Runnable{ boolean flag = false; public void run(){ for(int i=0;i<10;i++){ System.out.println("-----"+i); } }
多线程(创建线程-实现Runnable接口)
SmeagolYe的博客
10-10 171
[code="java"]class TWindow implements Runnable{ private int tickNum = 100; public void run(){ while(true){ if(tickNum >0){ System.out.println(Thread.currentThread().getName()" sale: "+...
Java多线程详解：Thread类与Runnable接口的应用与同步
- Java提供了两种创建线程的方式：继承自`Thread`类或实现`Runnable`接口。直接继承`Thread`类的优点是更简洁，可以直接重写`run()`方法。使用`Runnable`接口则通过`Thread`的构造函数接受一个实现了`Runnable`的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值