多线程—Thread类的用法

已于 2022-09-23 16:12:04 修改
阅读量718 收藏 3
点赞数
文章标签： java-ee
于 2022-03-23 10:44:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62824239/article/details/123653619
版权

目录


Java这个生态中最常用的并发编程方式是多线程。

什么是Thread类

在java标准库中，就提供了一个Thread类，来表示/操作线程。Thread类也可以视为Java标准库提供的API，创建好的Thread实例，其实和操作系统中的线程是一一对应的关系，操作系统，提供了一组关于线程的API，Java对于这组API进一步封装，就成了Thread类。

Thread类的基本用法

线程创建

最基本的创建方法

  • 方法一
lass MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}

//最基本的创建线程的方法
public class Demo1 {
    public static void main(String[] args) {
        Thread t=new MyThread();
        t.start();

    }
}

此方法是最简单的方法，创建子类继承自Thread，并且重写run方法。
在这里插入图片描述

  • 方法二（体现线程的并发执行）
class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Thread  t=new MyThread2();
        t.start();
        while(true){
            System.out.println("hello main");
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }

        }
    }
}

在这里插入图片描述

实现runnable接口

class MyRunnable implements  Runnable{
    @Override
    public void run() {
        System.out.println("hello");
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Thread t=new Thread(new MyRunnable());
        t.start();
    }
}

通过Runnable来描述任务的内容，进一步把描述好的任务交给Thread实例

使用匿名内部类

public class Demo4 {
    public static void main(String[] args) {
    //创建了一个匿名内部类，继承自Thread类，同时重写run方法，同时在new出这个匿名内部类的实例
        Thread t=new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        };
        t.start();
    }
}

public class Demo5 {
    public static void main(String[] args) {
    //new 的Runnable,针对这个创建的匿名内部类，同时new出的Runnable实例传给Thread的构造方法
       Thread t=new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("hello thread");
           }
       });
       t.start();
    }
}

lambda表达式

public class Demo6 {
    public static void main(String[] args) {
        //使用lambda代替了Runnable而已
        Thread t=new Thread(() -> {
            System.out.println("hello thread");
        });
        t.start();
    }
}

多线程能够提高任务完成的效率
有两个整数变量，分别对这两变量自增10亿次。
分别使用1个线程和2个线程

//多线程能够提高任务完成的效率
public class Demo7 {
    private static final long count=10_0000_0000;
    public static void serial(){
        long beg=System.currentTimeMillis();
        long a=0;
        for(long i=0;i<count;i++){
            a++;
        }
        long b=0;
        for(long i=0;i<count;i++){
            b++;
        }
        long end=System.currentTimeMillis();
        System.out.println("消耗时间"+(end-beg)+"ms");
    }
    public static void concurrent() throws InterruptedException {
        long beg=System.currentTimeMillis();
        Thread t1=new Thread(()->{
            long a=0;
            for(long i=0;i<count;i++){
                a++;
            }
        });
        t1.start();
        Thread t2=new Thread(()->{
            long b=0;
            for(long i=0;i<count;i++){
                b++;
            }
        });
        t2.start();
        //此处不能直接记录结束时间，现在这个求结束时间的代码是在main线程中
        //main和t1  t2是并发执行的关系，此处 t1   t2还没执行完，这里就开始记录结束时间，显然不准确
        //正确的做法是让main等待 t1  t2跑完了，在来记录结束时间
        //join的效果就是等待线程结束，t1.join就是让main等待t1结束，t2.join就是让main等待t2结束
        t1.join();
        t2.join();
        long end=System.currentTimeMillis();
        System.out.println("消耗时间："+(end-beg)+"ms");
    }

    public static void main(String[] args) throws InterruptedException {
        serial();
        concurrent();
    }
}

多线程不是万能的，并不是上了多线程，速度一定能提高。还得看具体的场景。
多线程特别适合那种CPU密集型的程序，程序要进行大量的计算，使用多线程可以更充分的利用CPU的多核资源。

Thread中的一些重要方法

启动一个线程

start决定了系统中是不是真的创建出线程。

t.run单纯的只是一个普通的方法，描述了任务的内容
t.start则是一个特殊的方法，内部会在系统中创建线程

public static void main(String[] args) {
        Thread t=new Thread(() -> {
            while(true){
                System.out.println("hello thread");
                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();
            }
        }

    }

在这里插入图片描述
如果把t.start 换成t.run 效果是不同的

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

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

    }

在这里插入图片描述
start和run的区别

 public static void main(String[] args) {
        Thread t=new Thread(() -> {
            for(int i=0;i<3;i++){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.run();

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

    }

执行效果
在这里插入图片描述

中断线程

手动的设置一个标志位

设置一个标志位（自己创建的，Boolean），来控制线程是否要执行结束。

 private static boolean isQuite=false;
    public static void main(String[] args) {
        Thread t=new Thread(() ->{
            while(!isQuite){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

    //只要把这个isQuite设为true，此时这个循环就退出了
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isQuite=true;
        System.out.println("终止t进程");
    }

执行效果
在这里插入图片描述
此处因为多个线程共用一个虚拟地址空间，因此main线程修改的isQuite和t线程判定的isQuite是同一个值

使用Thread中内置的一个标志位进行判断

在这里插入图片描述

public static void main(String[] args) {
        Thread  t=new Thread(() ->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }) ;
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在主线程中，调用interrupt方法，来中断这个线程
        //t.interrupt的意思就是让t线程被中断
        t.interrupt();

    }

在这里插入图片描述
当下的代码，一旦触发了异常之后，就进入catch语句，在catch中，就只是打了一个日志。printStackTrace是打印当前异常位置的代码调用栈，打完日志之后，就直接继续执行。

那么，上述的情况该如何解决呢？
加一个break即可。

public static void main(String[] args) {
        Thread  t=new Thread(() ->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //当触发异常之后，立即退出循环
                    break;
                }
            }

        }) ;
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //在主线程中，调用interrupt方法，来中断这个线程
        //t.interrupt的意思就是让t线程被中断
        t.interrupt();

    }

执行效果
在这里插入图片描述

线程等待

多个线程之间，调度顺序是不确定的。
线程之间的执行是按照调度器来安排的，这个 过程可以视为是“无序，随机”，但是这样不太好，有些时候，我们需要能够控制线程之间的顺序。
线程等待，就是其中一种控制线程执行顺序的手段。
此处的线程等待，主要是控制线程结束的先后顺序。

public static void main(String[] args) {
        Thread t=new Thread(() -> {
           for(int i=0;i<5;i++){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();

        //在主线程中就可以使用一个等待操作，来等待t线程执行结束
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       
    }

在这里插入图片描述

join操作默认情况下，是“死等”，这是不合理的。
因此join提供了另外一个版本，就是可以执行等待时间，最长等多久，如果等不到，就不等了。

public static void main(String[] args) {
        Thread t=new Thread(() -> {
           for(int i=0;i<5;i++){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();

        //在主线程中就可以使用一个等待操作，来等待t线程执行结束
        try {
            t.join(10000);//进入join也会产生阻塞，这个阻塞不会一直持续下去
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

获取当前线程引用

public static void main(String[] args) {
       Thread t=new Thread(){
           @Override
           public void run() {
               System.out.println(Thread.currentThread().getName());
           }
       };
       t.start();
        
        
         //这个操作是在main线程之后调用的，因此拿到的就是main这个线程的实例
        System.out.println(Thread.currentThread().getName());
    }
}

另一种方法

 public static void main(String[] args) {
       Thread t=new Thread(){
           @Override
           public void run() {
               //System.out.println(Thread.currentThread().getName());
               System.out.println(this.getName());
               
           }
       };
       t.start();


         //这个操作是在main线程之后调用的，因此拿到的就是main这个线程的实例
        System.out.println(Thread.currentThread().getName());
    }

在这里插入图片描述

金字塔端的蜗牛
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#多线程之Thread类详解
08-29
C#多线程之Thread类详解 C#多线程编程中，Thread类是最基本也是最重要的类之一，用于创建和控制线程。...Thread类是C#多线程编程的基石，了解Thread类的使用和实现原理对于编写高效的多线程程序非常重要。
多线程——Thread类
dgh112233的博客
03-31 267
Thread类 线程状态代表一个线程在生命周期中所处的状态或者阶段。 public class Thread implements Runnable { public enum State { 用new创建了之后，但是还未start运行 NEW, 正在执行状态 RUNNABLE, 阻塞状态 ...
1、java线程（thread）实现多线程的三种方法
康康的博客
07-07 867
进程（process）可以包含多个线程 三种创建方式： Thread class 继承Thread类不建议使用：避免OOP单继承局限性。 Runnable接口 实现Runnable接口推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用 Callable接口 实现Callable接口 注意：线程开启不一定立即执行，由CPU调度执行。 1、自定义线程类继承Thread类，重写run()方法，编写线程执行体，创建线程对象，调用start()方法启...
Java EE：Thread创建线程的五种写法（源码详解）
最新发布
linsc_05的博客
03-31 489
2、实现 Runnable 接口，this表示的是 MyRunnable 的引用，要表示当前线程对象需要使用。1、继承Thread 类，可以直接使用 this 表示当前线程对象的使用。currentThread() 方法。较为推荐lambda写法，较为方便~
【Java】多线程--Thread类基本用法
m0_57680308的博客
09-27 961
Thread类是Java中的一个封装类，用于实现多线程操作，下面是Thread类一些基本用法。
创建线程(异步/多线程)的四种方式-Thread/Runnable/ThreadPoolExecutor/Callable+Spring框架用法
天道酬勤
09-26 6960
创建线程(异步/多线程)的四种方式-Thread/Runnable/ThreadPoolExecutor/Callable+Spring框架用法
多线程（Thread）
qq_37107017的博客
02-16 442
多线程
Python多线程thread及模块使用实例
09-17
Python中的多线程是编程中实现并发执行任务的重要机制，特别是在需要执行耗时操作而不想阻塞用户界面或主线程的情况下。多线程允许我们同时处理多个任务，从而提高程序的响应性和效率。 标题和描述中提到的"thread...
Java多线程-Thread类的常用结构及线程优先级
01-27
理解并熟练掌握Thread类的构造器和方法，以及线程优先级的概念，对于编写高效、稳定的多线程程序至关重要。在实际开发中，应避免使用已过时的方法，合理利用线程调度机制，确保线程安全，提高程序性能。同时，对守护...
Python 多线程其他属性以及继承Thread类详解
09-18
本文将详细介绍Python多线程中的其他属性以及如何继承`Thread`类来创建自定义线程。 一、线程常用属性 1. `threading.currentThread()`：这个函数返回当前正在执行的线程对象。在多线程环境中，它可以用来获取调用...
多线程(二):Thread类的常见方法
qq_57735833的博客
08-16 529
Java多线程,Thread类得基本属性及其常用方法
一文带你搞懂C#多线程的5种写法
热门推荐
买烤麸烤饼儿的博客
05-29 3万+
一文带你搞懂C#多线程的5种写法 1.简介 超长警告！ 在学习本篇文章前你需要学习的相关知识： 线程基本知识 此篇文章简单总结了C#中主要的多线程实现方法，包括： Thread 线程 ThreadPool 线程池 Parallel Task 任务 BackgroundWorker组件 2. Thread类 2.1 概述 使用Thread类通过ThreadStart（无参数）或ParameterizedThreadStart（一个输入参数）类型的委托创建一个Thread对象，开启一个新线程，执行该委托
多线程thread
c_chuxuezhe_的博客
03-23 193
Java.Thread（多线程） 线程就是独立的执行路径 在线程运行，即使没有自己创建线程，后台也会有多个线程，如主线程，gc（垃圾回收）线程 main称之为主线程，为程序的入口，用于执行整个程序； 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预。 献丑操作时会带来额外的开销，如cpu调度时间，并发控制开销 线程创建 方法一： ​ 1.定义一个类继承Thread接口 ​ 2.重写这个接口的run（）方法； ​ 3.使用（实例化该方法） ​
【多线程】Thread 类及常见方法
m0_60494863的博客
05-14 4962
1.Thread 类 在Java标准库中，提供有一个Thread,来表示/操作线程。 Thread 类也可以视为Java 标准库提供的API。 创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。 操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类 2.创建线程 2.1继承Thread 类 通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法 （1）继承Thread 来创建一
Java线程①-创建线程和Thread类
hlizoo的博客
07-23 396
认识多线程；掌握多线程程序的编写，如何创建线程以及Thread类的使用 干货满满！你确定不来看看吗？
五分钟带你详细理解Java多线程
weixin_44598691的博客
03-15 1899
多线程 在传统的操作系统中，程序并不能独立运行，作为资源分配和独立运行的基本单位都是进程。 在未配置 OS 的系统中，程序的执行方式是顺序执行，即必须在一个程序执行完后，才允许另一个程序执行；在多道程序环境下，则允许多个程序并发执行。程序的这两种执行方式间有着显著的不同。也正是程序并发执行时的这种特征，才导致了在操作系统中引入进程的概念。 自从在 20 世纪 60 年代人们提出了进程的概...
Thread类实现多线程
weixin_45253459的博客
04-09 133
2、GetDomain： 返回当前线程正在其中运行的当前域。3、Interrupt： 中断处于WaitSleepJoin线程状态的线程。5、ResetAbort： 取消为当前线程请求的Abort。7、Sleep：静态方法，将当前线程阻塞指定的毫秒数。4、Join： 阻塞调用线程，直到某个线程终止时为止。Thread.CurrentThread 当前线程。6、Resume： 继续已挂起的线程。9、Suspend；1、Abort： 终止线程。//次线程开始执行指向的方法。8、Start：启动线程。
Thread多线程
weixin_53308618的博客
07-15 1536
多线程 相关知识概念 1.程序：是一个静态的概念，一段静态的代码，一般对应于操作系统中的一个可执行的文件，比如：我们要启动酷狗听音乐，则对应酷狗的可执行程序。当我们双击酷狗，则加载程序到内存中，开始执行该程序，于是产生了“进程”。 2.进程：执行中的程序叫做进程，它是一个动态的概念，进程是程序的一次动态执行过程，占用特定的地址空间，现代的操作系统都可以同时启动多个进程。比如：我在敲代码的同时还可以听音乐，看视频，浏览网页呢 3.线程：一个程序内部的一条执行路径。线程是一个连续的控制流程，是操作系统能够进行运
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
"Java多线程的创建方法之一是继承Thread类。这种方式涉及到线程的启动、线程的生命周期以及如何定义线程的行为。通过创建Thread的子类并重写run()方法，开发者可以定制线程执行的具体任务。然后通过创建Thread子类的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值