【多线程】-多线程的创建和使用

已于 2023-08-25 12:17:43 修改
阅读量36 收藏
点赞数
分类专栏： 多线程学习 文章标签： java 开发语言
于 2023-07-23 09:08:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/han178349/article/details/129733465
版权

本片学习多线程的几种创建方式

文章目录

线程的创建

1、继承 Thread 来创建一个线程类

Java标准库提供了一个类Thread能表示一个线程

实现步骤

  1. 继承 Thread 来创建一个线程类.重写run方法

  2. 创建 MyThread 类的实例

  3. 调用 start 方法启动线程

class MyTherad extends Thread{
    @Override
    public void run() {
        System.out.println("hello");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new Thread();//先创建MyThead实例，t的引用实际指向子类的实例
        t.start();//启动线程，在进程中搞了另一个流水线，新的流水线开始并发执行另提供逻辑
    }
}

。
在这里插入图片描述

上述代码涉及到了两个线程

  1. main方法对应的线程（一个进程至少得有一个线程）也可称为主线程

  2. 通过t.start创建的新线程

在这里插入图片描述
在这里插入图片描述
使用Tread的run描述线程入口

t.start会创建一个新的线程并执行
t.run()会执行里面的线程

run不是一个随便的方法，重写了父类的方法，
这种重写一般称为功能的扩展，不需要手动调用

2、实现使用 Runnable 接口

Runnable描述一个具体的任务
通过run方法重写
使用Runnable interface 来描述线程入口

实现步骤

  1. 实现 Runnable 接口
  2. 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.。
  3. 调用 start 方法
class MyRunable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunable runable = new MyRunable();
        Thread t = new Thread(runable);
        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用Runnable interface 来描述线程入口

继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.

实现 Runnable 接口, this 表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread()

3、匿名内部类创建 Thread 子类对象

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunable(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();

        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4、匿名内部类创建 Runnable 子类对象

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t =new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();

        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5、lambda 表达式创建 Runnable 子类对象

语法规则：

public static void main(String[] args) {
        Thread t = new Thread(() ->{
        });
    }

（）里面放参数，如果只有一个参数，（）可以省略，{}里面放函数体、代码

Thread类中的方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。
java代码中的Thread对象和操作系统中的线程是一一对应的。
在这里插入图片描述

在这里插入图片描述

  1. ID ：是线程的唯一标识，不同线程不会重复
  2. name：名称是各种调试工具用到
  3. state： 状态表示线程当前所处的一个情况，下面我们会进一步说明
  4. priority ：优先级高的线程理论上来说更容易被调度到
  5. daemon ：关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
  6. alive： 是否存活，即简单的理解，为 run 方法是否运行结束了
  7. 线程的中断问题

true 表示后台线程
false表示前台线程
前台线程会组织Java线程结束
必须得java线程中所以的前台线程都执行完，Java线程才能结束
创建的线程默认是前台的，可以通过setDeamon设置为后台的

6.实现Callable

类似Runnable ：描述了一个任务，一个线程干什么，通过run方法返回，返回值类型void

callable 方法有返回值

public class ThreadDemo27 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //这只是创建一个任务
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {//这个泛型类型是什么，call方法的返回值类型就是什么
                int sum = 0;
                for (int i = 0; i <= 10050; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        //Thrad不能直接传callable，需要包装一层
        FutureTask<Integer> futureTask = new FutureTask<>(callable);// FutureTask未来要执行的任务
        Thread t = new Thread(futureTask);
        t.start();

        System.out.println(futureTask.get());/*此处get就是获取上述任务call方法返回值的结果，call方法是t线程的，get方法是主线程的
        如何保证get的时候，t线程执行完了，get和join类似都会阻塞等待*/
    }
}

线程的使用

线程的启动

start 方法：真正从系统这里，创建一个线程，新的线程将会执行run方法

调用 start 方法, 才真的在操作系统的底层创建出一个线程.

run方法：表示线程的入口方法是什么（线程启动起来，要执行哪些逻辑）

线程的中断

线程的终止
本质上来说，让一个线程终止，办法只有一个，结束该线程的入口方法执行完毕（return，抛出异常）
方法：
1.给线程设定一个结束标志位

public class ThreadDemo9 {
    public static boolean isQuit = false;
    public static void main(String[] args) {
    public static boolean isQuit = false;//区别
        Thread t =new Thread(()->{
           while (!isQuit){
               System.out.println("hello t");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t,线程终止");
        });

        t.start();

        //在主线程中，修改isQit
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isQuit = true;
    }
}

lambda 表达式能否访问外部变量
Java要求变量捕获，捕获的变量必须是final或者“实际的final”（变量没有被final修饰，但代码中没有做出修改）

package threading;

public class ThreadDemo10 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            //currentThread是获取当前线程的实例
            //此处 currentThrerad得到的就是t
            //isInterruptead就是t对象里自带的一个标志位
           while (!Thread.currentThread().isInterrupted()){
               System.out.println("hello t");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   break;
               }
           }
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();//打印出当前异常位置的调用栈
        }
        //把t内部的标志位设置位true，，，默认的是false
        t.interrupt();//1.设置标志位为true，2.如果该线程正在阻塞（比如执行sleep，此时会把阻塞状态唤醒，通过抛异常的方式让sleep立即结束
        //当sleep被唤醒，sleep会自动把isInterrupted的标志位清空（true->false）,,,目的就是为了让线程自身能够对线程何时结束，有一个明确的控制
    }
}

三种方法，1.无视 2.立即 3. 等待
interrupt方法效果，不是让线程立即结束，而是告诉你线程该结束了，只是通知而不是命令
搞个break

线程的等待

join方法
调用谁，等待他等待

阻塞//走到这停下，当前这个线程暂时不参与cpu的调度

1.main线程调用t.join的时候，如果t还在运行，此时main线程阻塞，直到t执行完毕，main才从阻塞中解除，才继续执行
2.main线程调用t.join的时候，如果t已经结束了，此时join不会阻塞，就会立刻往下执行难，保证join先执行

join两个版本：无参版本（死等） 有参版本，指定最大等待时间，如果等待时间达到了上限，就不等了

获取当前线程的引用

public static Thread currentThread();           返回当前线程对象的引用

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
   }
}

休眠当前线程

使用Thread类的sleep()方法。
sleep()方法有两种重载形式：

  1. static void sleep(long millis)：使当前线程休眠指定的毫秒数。
  2. static void sleep(long millis, int nanos)：使当前线程休眠指定的毫秒数和纳秒数。
    代码示例
public class SleepThreadExample {
    public static void main(String[] args) {
        System.out.println("Main thread starts...");

        // 创建并启动新线程
        Thread childThread = new Thread(() -> {
            try {
                System.out.println("Child thread starts...");
                Thread.sleep(3000); // 休眠3秒
                System.out.println("Child thread resumes...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        childThread.start();

        // 主线程继续执行
        System.out.println("Main thread continues...");

        try {
            childThread.join(); // 等待子线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread ends.");
    }
}

线程的状态

NEW: 安排了工作, 还未开始行动
RUNNABLE: 就绪状态/可工作的. 又可以分成正在CPU上运行和准备好随时可以去CPU上运行

  1. Ready：线程在就绪队列上等待调度
  2. Running： 线程在CPU上运行

BLOCKED: 这几个都表示排队等着其他事情 //表示等待锁出现的状态
WAITING: 这几个都表示排队等着其他事情 //表示wait方法数出现的状态
TIMED_WAITING: 这几个都表示排队等着其他事情//指定时间等待
TERMINATED: 工作完成了.

public class ThreadDemo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){
                //为了防止hello把线程状态冲没了，先注释掉
                //System.out.println("hello");
            }
        });

        //在启动前，获取进程状态   NEW
        System.out.println(t.getState());

        t.start();


        //线程结束后的状态 TERMINATED
        Thread.sleep(2000);
        System.out.println(t.getState());

    }
}

状态转换图

一主线三分支
在这里插入图片描述

在这里插入图片描述

上进的派大星
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程-JDK5.0新增线程创建方式
02-03
Java多线程--JDK5.0新增线程创建方式
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4420
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
Java基础进阶多线程-四种创建方式
qq_46096136的博客
09-11 6302
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。调用start方法开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。run方法在分支栈的栈底部，main方法在主栈的栈底部。背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。好处：提高响应速度（减少了创建新线程的时间）
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
多线程之使用线程池创建线程
m0_49562228的博客
09-02 4959
1.使用线程池的优点 1.减少资源的消耗。重复利用已经创建的线程,避免频繁的创造和销毁线程，减少消耗。 2.提高响应速度。当执行任务时，不需要去创建线程再来执行，只要调动现有的线程来执行即可。 3.提高了线程的管理性。线程是稀缺资源，使用线程池可以进行统一的分配、调优和监控。 2.创建线程池的两种方案 1.通过Executors创建，它提供了四种线程池： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixe
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
SpringBoot--多线程处理
IT利刃出鞘的博客
07-31 1万+
本文介绍SpringBoot多线程处理的方案。
Java多线程之四种方法创建线程
liu320yj的博客
07-10 4506
创建多线程常用的方法有四种，继承Thread、实现Runnable接口、使用Callable和FutureTask和线程池
Java基础进阶多线程-生产者和消费者模式
qq_46096136的博客
09-11 7626
1、什么是“生产者和消费者模式”？2、3、。。，，只是通知，
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 5814
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java多线程-对比创建多线程的两种方式
01-25
Java多线程--对比创建多线程的两种方式
多线程编程-使用同步对象编程
03-02
1、互斥锁（mutex）2、条件变量(conditionvariable)3、多读单写锁(multi-read,single-writelock)4...·互斥锁·状态变量·读写锁·信号灯(信号量)·在两个或更多个进程内的线程可以合用一个同步变量。注意，同步变量应
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1046
介绍了Java泛型中的重要知识点——通配泛型及其应用。
springboot 获取maven打包时间
I do more ，you do less
04-30 474
【代码】springboot 获取maven打包时间。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1053
Java类与对象
leetcode16-3Sum Closest
我的程序人生
04-29 442
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
Spring Cloud——LoadBalancer
????
05-01 1882
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
【Java基础】三大特性——多态
qq_43714449的博客
05-05 343
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
多进程多线程--图形界面聊天室
10-28
多进程多线程--图形界面聊天室是一种基于socket(TCP)通信的应用程序，它可以实现多个用户之间的实时聊天。在该应用程序中，使用了多进程和多线程技术，其中一个进程负责终端操作，另一个进程负责图形化界面操作，两个进程之间通过管道进行通信。同时，为了提高程序的并发性能，使用了多线程技术，每个客户端连接到服务器时，服务器会为其创建一个新的线程，用于处理该客户端的请求。这样，多个客户端之间的聊天就可以同时进行，而不会相互影响。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值