初学线程，线程的概念及使用

最新推荐文章于 2023-01-29 16:39:27 发布
最新推荐文章于 2023-01-29 16:39:27 发布
阅读量196 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53134616/article/details/121783389
版权
本文详细介绍了Java中的线程概念，包括线程作为CPU资源分配的最小单元，以及线程与进程的关系。文章深入讲解了四种线程实现方式：继承Thread类、实现Runnable接口、实现Callable接口和使用线程池。此外，还阐述了线程的生命周期，包括新建、准备就绪、运行、阻塞和死亡五个状态。最后，提供了线程编程的小练习，帮助读者巩固所学知识。
摘要由CSDN通过智能技术生成




系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档




一、线程的概念

线程是CPU资源分配的最小单元

进程包含一个或多个线程

线程需要的资源更少，可以看做是一种轻量级的进程

线程会共享进程中的内存，线程也有独立的空间（栈、程序计数器）

线程互相通信更加方便




二、线程的实现




1.继承Thread类

1.继承Thread类

2.重写run方法

3.调用start启动线程

代码如下（示例）：

/**
 * 自定义线程类
 */
class MyThread extends Thread{
    /**
     * 执行指令
     */
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "执行了" + i + "次");
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {

        //创建线程对象
        MyThread thread = new MyThread();
        //启动线程
        thread.start();
    }

}

run与start的区别




2.实现Runnable接口

1.实现Runnable接口

2.实现run方法

3.创建实现Runbable接口的对象，传入Thread对象

4.启动线程

代码如下（示例）：

/**
 * 实现Runnable接口的类
 */
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--" + i);

        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        //创建Runnable对象，传入Thread对象
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        //匿名内部类
//        Thread thread = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 0; i < 100; i++) {
//                    System.out.println(Thread.currentThread().getName() + "--" + i);
//
//                }
//            }
//        });

        //lambda
//        new Thread(() -> {
//            for (int i = 0; i < 100; i++) {
//                    System.out.println(Thread.currentThread().getName() + "--" + i);
//                }
//        }).start();


    }
}

3.实现Callable接口

实现Callable接口可以返回值，继承Thread类和Runnable不行

  1. 实现Callable接口，实现call方法

  2. 创建Callable对象，传入FutureTask对象

  3. 创建FutureTask对象，传入Thread对象

  4. 启动线程

  5. 调用get方法得到返回结果

public class CallableDemo {
    public static void main(String[] args) {
        //创建Callable对象 传入FutureTask对象中
//        FutureTask<Long> task = new FutureTask<>(new MyCallable());
        FutureTask<Long> task = new FutureTask<>(() -> {
            long count = 0;
            for (long i = 0; i < 2000000000L; i++) {
                count = count + i;
            }
            return count;
        });
        //创建FutureTask对象 传入Thread对象中
        Thread thread = new Thread(task);
        thread.start();
        System.out.println("-----等待结果-----");
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4.使用线程池

线程池的概念和使用




三、线程的生命周期

线程的几种状态

  • 新建 new
  • 准备就绪 start
  • 运行 running
  • 阻塞 blocking
  • 死亡 dead

四、线程小练习

  1. 设计两个线程，一个线程负责打印1~１０0以内所有的偶数；然后，另外一个线程负责打印1~１０0以内所有的奇数。
Thread thread = new Thread(() -> {
            for (int i = 1; i <= 100; i+=2) {
                System.out.println("奇数为" + i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 2; i <= 100; i+=2) {
                System.out.println("偶数为" + i);
            }
        });
        thread.setPriority(Thread.MAX_PRIORITY);
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread.start();
        thread2.start();

2.实现一个线程，用于扫描某个目录下的所有文本文件（包括：java、txt、html），并将文字内容打印出来。

public static void select(String path){
        File file = new File(path);
        if (file.isDirectory()) {
            File[] files = file.listFiles((dir,name) -> name.endsWith(".java") | name.endsWith(".html") | name.endsWith(".txt") | dir.isDirectory());
            if (files != null){
                for (File f:files) {
                    select(f.getPath());
                }
            }
        }else {
            try(BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(file),"gbk"))){
                String str;
                while ((str = input.readLine()) != null){
                    System.out.println(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            select("D:\\123");
        });
        thread.start();
    }

3.某人正在看电视连续剧，从第1~88集，看到第10集时，来了一个送快递的，收完快递后后，继续看电视。

Thread thread = new Thread(() -> {
            for (int i = 1; i <= 88; i++) {
                System.out.println("看到第" + i + "集");
                if (i == 18){
                    try {
                        System.out.println("快递到了");
                        Thread.sleep(5000);
                        System.out.println("收完快递，继续看电视");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        });

        thread.start();

4.多线程模拟龟兔赛跑：

乌龟和兔子进行1000米赛跑，兔子前进5米，乌龟只能前进1米。

但兔子每20米要休息500毫秒，而乌龟是每100米休息500毫秒。

谁先到终点就结束程序，并显示获胜方

static Thread thread = null;
    static Thread thread2 = null;
    public static void main(String[] args) {
        thread = new Thread(() -> {
            for (int i = 0; i <= 1000; i+=5) {
                System.out.println("兔子跑了" + i + "米");

                if (i == 1000){
                    System.out.println("兔子赢了");
                    System.exit(0);

                }else if ( i != 0 && i % 20 == 0 ){
                    try {
                        System.out.println("兔子休息了");
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        });
        thread2 = new Thread(() -> {
            for (int i = 0; i <= 1000; i++) {
                System.out.println("乌龟跑了" + i + "米");

                if (i == 1000){
                    System.out.println("乌龟赢了");
                    System.exit(0);
                }else if ( i != 0 && i % 100 == 0 ){
                    try {
                        System.out.println("乌龟休息了");
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        thread.start();
        thread2.start();
    }

总结

今天学习了线程的概念和使用，了解了程序如何运行，线程的生命周期

qq_53134616
关注
线程的基本使用
m0_60391870的博客
04-04 918
线程使用:Thread的基本用法一、线程的创建方法一：继承Thread方法二： 实现 Runnable 接口方法三：匿名内部类创建 Thread 子类对象方式四：匿名内部类创建 Runnable 子类对象方法五：二：线程中断方法一：手动设置一个标记位方法二： 使用 Thread.interrupted() Thread.currentThread().isInterrupted() 代替自定义标志位.三、线程等待四、线程休眠五、获取线程实例 一、线程的创建 方法一：继承Thread //继承
【操作系统】线程的使用
半生瓜のblog
08-28 664
- 使用fork创建进程以执行新的任务，该方式的代价很高——子进程将父进程的所有资源都复制一遍。 - 多个进程之间不会直接共享内存。 - `进程是系统分配资源的基本单位`，`线程是进程的基本执行单元`，一个进程的所有任务都在线程中执行，进程想要执行任务，必须得有线程，进程至少要有一条线程，程序启动会默认开启一条线程，这条线程被称为`主线程或UI线程`。...
QT中this->moveToThread(m_thread);是什么意思
weixin_35757191的博客
01-29 298
"this->moveToThread(m_thread);" 意思是将当前对象(通过 "this" 指针指向)移动到名为 "m_thread" 的线程中。这意味着该对象的所有槽函数和信号将在 "m_thread" 线程中运行。 ...
MThread:实现线程池已有的功能，同时对线程池的本身的使用与运行情况提供监控；与ILog组件配合使用，可以实现线程上下文的自动切换
06-17
monitor-thread 普通JDK自带的线程池时无法实现线程池的自动切换，基于监控与上下文自动切换的需求，封住了一套taxi开头的线程池，接入方式很简单，它的使用方式与Jdk的使用基本方式一致，只需在对应的类前加一个Taxi，现将对应方式列举如下： 1）Executors<-------->TaxiExecutors Example： private final ExecutorService producerPool = TaxiExecutors.newCachedThreadPool(new ThreadFactoryBuilder("Scheduled-EncourageOrderPushProducer-scheduler")); 2）ScheduledThreadPoolExecutor<-------->WrapTaxiScheduledThreadPoolEx
多线程资料，初学者使用
10-16
### 多线程基础知识 #### 一、概念与特性 **多线程**是指程序能够同时执行多个线程的能力。在计算机系统中，程序通常被理解为资源分配的基本单位，而线程则...掌握这些基本概念和技术是理解和应用多线程编程的关键。
Python 多线程Threading初学教程
09-21
创建新线程时，可以使用`threading.Thread()`，传入`target`参数指定线程要执行的函数，例如： ```python def thread_job(): print('This is a thread of %s' % threading.current_thread()) def main(): thread...
线程应用，主要展示初学者同步线程的认识与介绍
最新发布
04-16
附件为视频案例。主要对初学者展示了同步线程的认识 案例介绍了兔子与乌龟赛跑的同步线程，比较形象的介绍了大家对线程的初步理解
易语言多线程及线程参数传递案例.zip
09-24
在编程中，多线程是一个关键的概念，特别是在处理大量数据或者需要并行执行任务时。易语言提供了多线程的支持，使得开发者能够充分利用现代计算机的多核处理器资源，提高程序的运行效率。 线程是操作系统分配CPU...
pthread详解
01-04 6096
原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处 、作者信息和本声明。否则将追究法律责 http://blog.csdn.net/jiajun2001/article/details/12624923我并不假定你会使用Linux的线程，所以在这里就简单的介绍一下。如果你之前有过多线程方面的编程经验，完全可以忽略本文的内容，因为它非常的初级。首先说明一下，在Linux编写多线程程序需要包
终止线程的三种方法
涑飏的专栏
07-17 9万+
有三种方法可以使终止线程。    1.  使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。    2.  使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。    3.  使用interr
Thread协议介绍
MXB1的博客
12-15 1万+
Thread，由三星、Nest、ARM、Big Ass Fans、飞思卡尔和Silicon Labs公司联合推出， 是一种基于IP的无线网络协议，用来连接家里的智能产品。 比较常用的网络协议有 WiFi、蓝牙、ZigBee、Z-Wave，不过都有不足： WiFi的功耗比较大，适合传输大量的数据； 蓝牙功耗比较低，但还存在蓝牙2.0与蓝牙4.0并存的混乱局面，且不支持IPv6； ZigBee技术比较复杂，研发成本高 [1] ； Z-Wave由丹麦公司Zensys主导，暂时还没有ZigBee联盟强大。 Th
Pthread线程基础学习
我的梦
11-03 5412
后面会尝试使用冰搜和goole搜索来学习技术，互联网上知识的学习也是符合二八定律的，既然如此，我们何不去选择最好的文章呢。 文章参考： https://randu.org/tutorials/threads/ http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html https://blog.csdn.net/stpeace/...
HandlerThread的使用以及原理
许佳佳的博客
02-28 2万+
HandlerThread 如果已经理解Handler,Loop,MessageQueue的工作原理看此篇文章会非常简单，若没有了解的读者，可以看下面的文章： Handler类和Handler,Loop,MessageQueue的工作原理 首先我们先看一下官方的描述： Handy class for starting a new thread that has a loo...
JAVA线程之Thread类详解
热门推荐
MC的博客
05-30 9万+
ss
C# 多线程一： Thread 的简单理解与运用
SmillCool的博客
09-29 9881
C# Thread/线程/多线程/IsBackground/Priority
线程的使用
weixin_48656058的博客
12-01 4375
线程 首先要了解进程和线程的区别: 进程是唯一的,一个进程可以开启多个线程。 比如:你的电脑开机了,你任务管理器里面运行的程序就是线程 1.线程的生命周期有五种状态: 创建、就绪、运行、阻塞、死亡 1.1 创建(创建方式往下找): 创建一个线程,线程进入创建状态。 1.2 就绪: start()方法用于使一个线程进入就绪状态。 1.3 运行: 执行run()方法使线程进入运行状态 1.4 阻塞: wait(等待)会让线程进入阻塞状态,会失去所占用的资源; 还有其他方式可以让一
线程的用法
weixin_43748216的博客
03-14 1495
一、线程的状态 从创建到消亡，线程一般包含以下几种状态：创建（new），就绪（runnable），运行（running），阻塞（blocked），waiting，time_waiting，消亡（dead）。 当需要新起一个线程去执行某个子任务的时候，线程被创建（new）。创建之后还需要JVM为其分配一些内存空间后，才会进入就绪状态（runnable）。 线程进入就绪状态后，不一定会立刻得到C...
Java多线程基础：概念、使用与同步
该书深入浅出地介绍了Java中的线程编程，特别是针对初学者。章节15集中于多线程的核心内容，强调理解线程是关键。在学习过程中，读者需要掌握的方法调用过程、程序执行流程、继承和覆盖、接口和内部类等基础知识是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值