java线程基本使用（创建线程）

最新推荐文章于 2024-04-19 21:50:42 发布
最新推荐文章于 2024-04-19 21:50:42 发布
阅读量181 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57025392/article/details/122332810
版权

java线程基本使用（创建线程）

创建线程的两种方式

1.继承Thread类，重写run方法

演示：
1.编写程序，开启一个线程，该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”
package threaduse;

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();//启动线程-> 最终会执行 cat 
    }
}

//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
@SuppressWarnings({"all"})
class Cat extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("喵喵，我是小猫");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
2.对上题进行改进：当输出80次后，结束进程
package threaduse;

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();//启动线程-> 最终会执行 cat
    }
}

//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
@SuppressWarnings({"all"})
class Cat extends Thread{
    @Override
    public void run() {
        int count=1;
        while(true){
            System.out.println("喵喵，我是小猫"+count);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count!=80){
                count++;
            }
            else{
                break;
            }
        }
    }
}
3.使用 JConsole 监控线程执行情况
package threaduse;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();//启动线程-> 最终会执行 cat
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程i="+i);
            Thread.sleep(1000);
        }
    }
}

//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
@SuppressWarnings({"all"})
class Cat extends Thread{
    @Override
    public void run() {
        int count=1;
        while(true){
            System.out.println("喵喵，我是小猫"+count);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count!=80){
                count++;
            }
            else{
                break;
            }
        }
    }
}

主线程挂了，子线程不一定结束（通过以上例子说明主线程main退出后，子线程Thread-0继续执行）

为什么是调用start方法而不是run方法
案例
package threaduse;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
//        cat.start();//启动线程-> 最终会执行 cat

        //读源码
/*
    (1)
        public synchronized void start() {
            start0();
        }
    (2)
        //start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现
        //真正实现多线程的效果， 是 start0(), 而不是 run
            private native void start0();
*/

        cat.run();
        //cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行
        //说明: 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 main
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程i="+i);
            Thread.sleep(1000);
        }
    }
}

//说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
@SuppressWarnings({"all"})
class Cat extends Thread{
    @Override
    public void run() {
        int count=1;
        while(true){
            System.out.println("喵喵, 我是小猫咪" + count + " 线程名=" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count!=80){
                count++;
            }
            else{
                break;
            }
        }
    }
}
解释：

1.首先 start 方法调用 start0()方法

public synchronized void start(){
	.....
	start0();
	.....
}

  1. start0()是本地方法，是 JVM 调用，底层是c/c++实现

    真正实现多线程的效果是 start0(),而不是run

    private native void start0();

  2. start()调用start0()方法后，该线程并不一定立马执行，只是将线程变成可运行状态。具体说明时候执行，取决于CPU，由CPU统一调度

2.实现Runnable接口，重写run方法

说明：

**1.**java是单继承，在某些情况下一个类可能继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了

**2.**java设计者提供了另一个方式创建线程，就是通过实现Runnable接口来创建线程

应用案例：

编写程序，可以每隔1秒，在控制台输出“小狗汪汪叫”，当输出10次后，自动退出。使用实现Runnable接口的方式实现

package threaduse;

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
//        dog.start();这里不能调用start
        //创建了Thread对象，把dog对象，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}
@SuppressWarnings({"all"})
class Dog implements Runnable{
    private int count=0;
    @Override
    public void run() {
        while(true){
            System.out.println("小狗汪汪叫..."+(++count)+"---"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}

编写一个程序，创建两个线程，一个线程每隔1秒输出“hello Thread”，输出10次退出，一个每隔1秒输出“hi”，输出5次退出

package threaduse;

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread0 = new Thread(t1);
        Thread thread1 = new Thread(t2);
        thread0.start();
        thread1.start();
//        new Thread(new T1()).start();//简写
    }
}
class T1 implements  Runnable{
    private int count=0;
    @Override
    public void run() {
        while(true){
            System.out.println("hello Thread"+(++count)+"---"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}
class T2 implements  Runnable{
    private int count=0;
    @Override
    public void run() {
        while(true){
            System.out.println("hi"+(++count)+"---"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==5){
                break;
            }
        }
    }
}

继承Thread vs 实现Runnable 的区别

**1.**从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别。

**2.**实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

Alonzo de blog
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面试官：Java 线程如何启动的？
m0_68103752的博客
04-29 570
工作这么久还是不知道Java 线程如何启动的？这道题可能会与不会这一个题并不会让你代码有多牛、有多好，但是你的技术栈深度和广度，决定你的编程职业生涯是否有一条康庄大道。 一、线程启动分析 new Thread(() -> { // todo }).start(); Java 的线程创建和启动非常简单，但如果问一个线程是怎么启动起来的往往并不清楚，甚至不知道为什么启动时是调用start()，而不是调用run()方法呢？ 那么，为了让大家有一个更直观的认知，我们先站在上帝视角。把这段
Java基础（进程与线程，线程的创建）
CodeSheep1的博客
08-30 353
线程11 进程和线程1.1 进程1.2 线程2 并发和并行3 时间片3.1 概述3.2 调度4 main线程5 线程的创建和启动6 Runnable接口7 线程的名字8 线程的分类9 线程优先级10 线程组11 线程状态 1 进程和线程 1.1 进程 在计算机中，进程代表了内存中正在运行的应用程序，计算机中的资源（cpu 内存 磁盘 网络等），会按照需求分配给每个进程，从而这个进程对应的应用程序就可以使用这些资源了。 在操作系统中，启动一个应用程序的时候，会有一个或多个进程同时被创建，这些进程其实就表示了
Java中的神秘之旅：揭秘native修饰的start0()方法的实现
一名Java语言狂热分子。
06-30 418
在Java中，拥有多线程能力是其强大之处之一。然而，你是否曾经好奇过在Java中如何启动一个线程？这其中涉及到一个神秘的方法——start0()。让我们一起揭开这个谜团，探索start0()方法的具体实现。start0()通过本文，我们对Java中的start0()方法有了更深入的了解。这个本地方法作为线程启动的关键步骤之一，负责分配资源、创建操作系统级线程，并进行状态更新。虽然我们通常不需要直接操作它，了解其实现细节可以帮助我们更好地理解Java多线程机制。
【Java多线程的使用详解】
最新发布
Java之行
04-19 955
Java多线程的使用详解
聊一聊多线程的 run（） 和 start（），挖一挖start0
默默不代表沉默
11-11 4092
首先是结论，应该大家知道： 调用start（） 会触发多线程执行 ； 调用run（） 还是当做执行了一个普通方法，没有多线程执行。 start（）示例： public class MyThread extends Thread { @SneakyThrows @Override public void run(){ sleep(5000); System.out.println("run 内容打印 "); } publ..
java的Thread类start0方法源码
计算机王的博客
03-17 3190
带着几个问题去看源码 1、如何找到native方法的源码 2、Java的Thread对象、JavaThread、OSThread、操作系统线程 3、Java线程与操作系统线程的关联 4、Java线程保存了哪些操作系统线程数据 5、怎么执行到run方法的 首先第一个问题native的方法是通过jin与c/c++进行通信的jin有个规则一个java类中有native方法那么就会有一个.h的文件.h文件是c/c++用来定义变量、方法的所以想看native方法的源码可以直接去jdk源码搜索类名找它的.c或.cpp文
Java 线程的使用
weixin_53472653的博客
06-02 3268
尚硅谷学习笔记
Java- 简单了解线程 线程创建和联合线程(一)
暮光之城
11-03 544
简单的了解一下JAVA的多线程后，觉的C#好像做的更好，C#通过委托的方式来实现多线程，当然JAVA实现多线程也很方便，但还是觉的C#做的更好。那么什么是多线程？一个进程中又可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索，如果要一程序中实现多段代码同时交替运行，就需要产生多个线程。 　 线程的生命周期 　　新建→运行→中断→死亡 　　中断有： 1.当前线程切换到另一个线程时发
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
Java中线程的基本方法使用技巧
08-29
Java中的线程是多任务并行处理的核心...总之，理解并熟练使用Java线程的基本方法是成为合格的Java并发程序员的基础。通过实践和不断学习，我们可以更好地应对多线程环境中的各种挑战，编写出更健壮、高效的并发程序。
Java继承Thread类创建线程类示例
08-25
Java继承Thread类创建线程类是Java线程编程中的一种常见方法。通过继承Thread类，可以创建自定义的线程类，并重写run方法来实现线程的执行体。本文将通过实例形式，详细介绍Java继承Thread类创建线程类的步骤和注意...
如何创建并运行java线程
01-20
Java线程类也是一个object类，它的实例都继承自java.lang.Thread或其子类。 可以用如下方式用java中创建一个线程： 　Tread thread = new Thread(); 　执行该线程可以调用该线程的start()方法: 　thread.start();...
Java并发编程之创建线程
09-02
在Java并发编程中，创建线程是实现多任务并行执行的关键。线程允许程序中的不同部分同时运行，提高应用程序的响应速度和效率。本文将深入探讨Java中创建线程的两种主要方法：继承`Thread`类和实现`Runnable`接口。 ...
JAVA进阶学习笔记(1)：多线程
LeavingBook的博客
09-01 641
1 基本概念 1.1 程序 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 1.2 进程 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 。 1.3 线程 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 1.若一个进程同一时间并行执行多个线程，就是支持多线程的 2.线程
Java-线程的使用
好好学习，天天向上。
09-12 127
为了不导致线程安全问题，应该避免修改这些共享的变量，或者使用synchronized关键字等方案来保证线程安全。**yield() ** ：线程的“礼让”，该线程“礼让”其他线程先执行；因此建议使用实现Runnable接口方式来创建线程。**join() ** ：线程的插队；
【JavaSE】线程的使用
别倒在黎明之前的博客
07-13 159
线程的介绍以及使用方法
Java—线程基本使用
qq_34577961的博客
11-13 276
Thread基本使用
java 线程 (一) 线程的简单使用
热门推荐
llk15884975173的博客
10-24 1万+
大家好，从今天开始，我和大家一起来探讨 java 中线程的使用。线程是 java 知识体系中非常重要的一部分，我将写一系列的文章来详细的介绍 java 线程中需要掌握的知识。如果你是 java 线程的初学者，本系列文章你一定不要错过哦。 本篇文章是 java 线程系列文章的第一篇文章，主要介绍进程与线程的概念和 java 中如何使用线程。 1 进程与线程 1.1 进程的概念 首先我们先来介绍一下什么是进程。 进程可以理解为一个个正在执行的应用程序，比如我们使用网易云音乐软件播放音乐，同时我们在使用 WP
多线程笔记2
08-08
Java线程模型基于操作系统原生线程，提供了两种创建线程的方式： 1. 扩展`java.lang.Thread`类：创建一个Thread的子类，并重写`run()`方法。当线程启动时，`run()`方法会被执行。这种方式使得线程与特定业务逻辑...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Alonzo de blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值