Thread类的基本用法

最新推荐文章于 2024-03-11 22:38:14 发布
最新推荐文章于 2024-03-11 22:38:14 发布
阅读量54 收藏
点赞数
文章标签： java java ee 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45821474/article/details/125991151
版权

线程的创建

我们有许多种方式来创建一个线程，我们在这里主要阐述五种创建线程的方式。

1.继承Thread类

public class CreateThread1 {
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("thread_0");
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}
  • 创建一个MyThread类继承Thread类
  • 重写run方法
  • start启动线程

2.实现Runnable接口

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

    public static void main(String[] args) {
        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
}
  • 实现Runnable接口
  • 重写run方法
  • start启动线程

3.使用匿名内部类

这种方法的本质同1，2一样，只不过使用了匿名内部类，让我们用两个小例子来阐述这种方法的使用

//继承Thread类，使用匿名内部类的写法
public class CreateThread3 {
    public static void main(String[] args) {
        Thread t3 = new Thread(){
            @Override
            public void run() {
                System.out.println("thread0");;
            }
        };
        t3.start();
    }
}

//实现Runnable接口，使用匿名内部类的写法
public class CreateThread4 {
    public static void main(String[] args) {
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread_0");
            }
        });
        t4.start();
    }
}

4.使用lambda表达式

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

我们可以看到，Runnable接口是一个函数式接口，可以使用lambda表达式
从而，实现Runnable接口可以写成

public class CreateThread5 {
    public static void main(String[] args) {
        Thread t5 = new Thread(() -> {
            System.out.println("thread_0");
        });
        t5.start();
    }
}

线程的启动

在上一个部分，我们可以看到，我们通过t.start()来启动线程，而没有通过t.run()来启动线程，这是什么原因呢?

start()和run()的区别

在探究start()和run()的区别之前，我们来看一下这样一个例子

public class StartAndRun {
    static class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.getName()+"；\t"+i);
            }
        }

        public MyThread(String name) {
            super(name);
        }
    }

    public static void main(String[] args) {
        MyThread t1 =new MyThread("thread_1");
        MyThread t2 =new MyThread("thread_2");
        MyThread t3 =new MyThread("thread_3");
        t1.start();//t1.run()
        t2.start();//t2.run()
        t3.start();//t3.run()
    }
}

我们执行这么一段代码，可以得到如下的结果：

startrun
thread_2； 0
thread_3； 0
thread_1； 0
thread_2； 1
thread_1； 1
thread_3； 1
thread_2； 2
thread_3； 2
thread_1； 2
thread_1； 3
thread_2； 3
thread_3； 3
thread_1； 4
thread_2； 4
thread_3； 4		thread_1； 0
thread_1； 1
thread_1； 2
thread_1； 3
thread_1； 4
thread_2； 0
thread_2； 1
thread_2； 2
thread_2； 3
thread_2； 4
thread_3； 0
thread_3； 1
thread_3； 2
thread_3； 3
thread_3； 4

左边为start()方法的执行结果，右边为run()方法的执行结果
我们可以看到，start方法的thread_?打印的顺序是thread_1，thread_2，thread_3为一组一起打印的，而run方法的thread_?则先是1，再是2，再是3。
这表明run方法没有启用多线程

事实也确是如此，我们查看start源码可以发现，真正创建线程的是start方法中调用的start0()方法。run()只是一个普通的成员方法，他只是为start()方法提供一个“行动指南”。

结论：调用start方法，才真正的在操作系统的底层创建出一个线程，并将其置于就绪状态，随时准备调度cpu资源。run()方法只是一个普通的成员方法，其为start()提供一个“行动指南”。

线程的中断

当一个线程进入到工作状态，他就会按照重写的Run方法进行工作，有时候，我们需要停止这种工作状态，这里就涉及到我们停止线程的方式了。

目前常见的有以下两种方式来停止线程：

1.通过共享的标记来进行沟通
2.调用interrupt()方法来通知

共享标记

public class InterruptThread {
    public static boolean flg = false;

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

        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flg = true;
        System.out.println("主线程结束");
    }
}

通过共享一个标志flg来控制线程

调用Interrupt()方法

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

        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();
        System.out.println("主线程结束");
    }
}
  • 通过Interrupt()来给进程添加一个中断标记，用Thread.currentThread().isInterrupted()来标记位的判断
    • 如果线程因为调用wait/join/sleep等方法而被阻塞挂起，则以InterruptException异常的形式通知，清除中断标志，当InterruptException出现的时候，要不要结束线程取决于catch中代码的写法。
    • 正常情况下，只是内部一个中断标记被设置
      • Thread.interrupted()会清除中断标记
      • Thread.currentThread().isInterrupted() 不清除中断标记

线程的等待

public class ThreadJoin {
    public static void main(String[] args) throws InterruptedException {
        Runnable target = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" working...");
            }
        };

        Thread t1 = new Thread(target,"thread_1");
        Thread t2 = new Thread(target,"thread_2");
        System.out.println("thread_1 start...");
        t1.start();
        t1.join();
        System.out.println("thread_1 end...，thread_2 start...");
        t2.start();
        t2.join();
        System.out.println("thread_2 end...");

    }
}

通过.join()方法使线程等待，在哪个线程调用t.join()方法，则哪个线程等待t的结束。
以上述代码为例，t1.join()在主线程中书写，则t1结束后，主线程再继续往下执行。

线程休眠

线程的休眠我们在之前的代码中用的比较多了，我们通过Thread.sleep()方法来使当前线程进行休眠。
但有一点要记得，因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

获取当前线程的引用

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

我们用该方法来获取当前线程的引用。

qq_45821474
关注
Thread 类的基本用法
qq_45806560的博客
07-27 560
线程的类(Thread)
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1914
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
java中Thread用法
热门推荐
初心
05-13 1万+
一.线程的状态二.上下文切换三.Thread类中的方法线程的状态　在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。　　线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、
Thread类的基本用法1
r798303142b的专栏
06-02 608
一、             Thread类的基本用法 通过System.Threading.Thread类可以开始新的线程，并在线程堆栈中运行静态或实例方法。可以通过Thread类的的构造方法传递一个无参数，并且不返回值（返回void）的委托(ThreadStart)，这个委托的定义如下： [ComVisibleAttribute(true)] public delegate
Thread类的使用
qq_37023928的博客
05-08 381
作者：Matrix海子 出处：http://www.cnblogs.com/dolphin0520/ 原文链接：http://www.cnblogs.com/dolphin0520/p/3920357.html 一.线程的状态   在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。   线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(b
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
Thread 类及常见方法
weixin_58697177的博客
07-21 1250
系统对于线程的调度是随机的，假设我们的机器上面存在很多的进程和线程，此时 CPU 调度一圈，消耗的时间可能就比较长，此时就可能导致某个线程隔了很久也没有调度上去，这个可能大多数人都遇到过这种情况：某些时候，电脑卡了，点击某个窗口，提示“未响应”，让我们选择等待还是结束进程。此时会出现这样的提示信息，意思是 isQuit 这个变量不是常量或者“实际常量”，常量就是 final 修饰的，“实际常量”是没有final修饰，但是也没有其他代码尝试修改的变量，但是我们在下面对 isQuit 进行了修改，所以不行。
C#winform程序Thread(线程)和ThreadPool(线程池)的基本用法
11-17
本文将详细介绍C#中Thread和ThreadPool的基本用法及其应用场景。 ## 1. 线程（Thread） ### 1.1 创建线程 创建线程主要通过以下两种方式： - `System.Threading.Thread` 类：通过实例化该类并调用其`Start()`...
C# Thread类最基本使用示例
08-20
通过使用Thread后，一个进程可以创建一个或多个线程以执行与该进程关联的部分程序代码。使用 ThreadStart 委托或 ParameterizedThreadStart 委托指定由线程执行的程序代码。使用 ParameterizedThreadStart 委托可以将数据传递到线程过程。
【多线程】Thread类的使用
最新发布
weixin_73950267的博客
03-11 1025
Thread类的使用
一文搞懂Thread类核心用法
qq_34800986的博客
03-12 531
简介 直奔主题，从源码解析Thread的用法以及多线程的使用 public class Thread extends Object implements Runnable // Runnable接口定 public interface Runnable { public abstract void run(); } //Thread重写run方法 @Override pu...
Java多线程基础-4：详解Thread类及其基本用法
wyd_333的博客
04-03 4967
万字详解Java多线程编程类Thread及其基本用法。
Java并发编程：Thread类的使用
weixin_30432579的博客
08-19 280
Java并发编程：Thread类的使用 　　在前面2篇文章分别讲到了线程和进程的由来、以及如何在Java中怎么创建线程和进程。今天我们来学习一下Thread类，在学习Thread类之前，先介绍与线程相关知识：线程的几种状态、上下文切换，然后接着介绍Thread类中的方法的具体使用。 　　以下是本文的目录大纲： 　　一.线程的状态 　　二.上下文切换 　　三.Thread类中的...
Thread类
willlu10的博客
03-25 1万+
　1 start方法　　start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。　　2 run方法　　run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要...
Java Thread类详解：构造器、方法与优先级
首先，让我们了解一下Thread类的基本构造器： 1. **Thread()**: 无参构造器，用于创建一个新的线程对象，但没有指定线程名称。当子类没有提供自定义构造器时，系统默认使用此构造器，并通过super()调用父类Thread的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值