Thread类的基本用法

最新推荐文章于 2023-11-08 09:02:26 发布
最新推荐文章于 2023-11-08 09:02:26 发布
阅读量297 收藏
点赞数 1
分类专栏： javaee 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61427900/article/details/126599439
版权

1.线程创建

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

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread t=new MyThread();//把线程和线程要完成的任务耦合在一起
        t.start();//另外启动新线程，执行run中的逻辑，是一个单独执行流，和现有执行流不相关。并发执行
        System.out.println("hello main");
    }
}

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

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello MyRunnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable myRunnable=new MyRunnable();
        Thread t=new Thread(myRunnable);//把线程要干的事和线程分开，使用Runnable专门表示线程要完成的工作
        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.继承Thread类，使用匿名内部类

public class Demo3 {
    /**
     *使用匿名内部类，创建thread子类同时实例化出一个thread对象
     * @param args
     */
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

4.实现Runnable接口，使用匿名内部类

public class Demo4 {
    /**
     * 使用匿名内部类 实现Runnable接口
     * @param args
     */
    public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

5.使用lambda表达式（推荐）

public class Demo5 {
    /**
     * lambda表达式，推荐写法
     * @param args
     */
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2.启动线程（start和run的区别）

class MyThread extends Thread{
    @Override
    public void run() {
        while(true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread t=new MyThread();
        //t.run();直接调用run
        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 第一个截图是调用start，是创建线程，在新线程里面执行代码，和main线程并发执行。

第二个截图是调用run，没有创建线程，而是在原来的main线程执行代码

线程中断

本质是让run方法快点结束，而不是让run执行一般中止。

方法1：自己定义一个标志位，作为线程是否结束的标志

public class Demo9 {
    public static boolean isQuit=false;//自定义一个标志
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        isQuit=true;//3秒后线程结束
    }
}

方法2：使用标准库自带的标记

public class Demo10 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                //currentThread()是一个静态方法，通过它可以获得当前线程对应的Thread对象
                //isInterrupted()用于判定标志位
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException(e);

                    //1.立即结束线程
                    //break;

                    //2.不做处理

                    //3.稍后处理
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        throw new RuntimeException(ex);
                    }
                    break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t.interrupt();//通过他中断线程，设置标志位为true
        /*
        interrupt方法有两种情况
        1.t线程在运行时，会设置标志位为true
        2.t线程在阻塞状态（sleep)，不会设置标志位，而是触发InterruptedException，这个异常会把sleep提前唤醒.
        所以处理异常时直接break;
         */
    }
}

线程等待

线程之间的调度是不确定的，可以通过join()方法控制线程的结束顺序

public class Demo11 {
    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) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        try {
            t.join();//main线程进入阻塞，t线程继续参与调度
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("hello main");

    }
}

如果调用join方法之前，t线程已经结束，此时join不需要阻塞等待。

线程休眠sleep() 

操作系统管理线程PCB的时候，是有多了链表的。其中有阻塞队列，就绪队列，调用sleep()时PCB会从 就绪队列移动 到 阻塞队列。只有就绪队列才会参与cpu调度，当sleep时间到了就会从新回到就绪队列（不代表立即在cpu上执行）

指挥部在下面
关注
专栏目录
Thread 类的基本用法
qq_45806560的博客
07-27 579
线程的类(Thread)
Java Thread类的基本用法
Naion的博客
07-23 3428
简单介绍了Java中Thread类的几个基本的知识点。
Thread子类实例化线程对象
qq_37504771的博客
06-19 919
'''通过Thread的子类实例化线程对象，这样可以让线程更具有灵活性'''import threadingfrom time import ctime, sleeploops = [4,2]class MyThread(threading.Thread):           '''继承Thread类，初始化参数'''    def __init__(self, func , args, nam...
线程Thread类的基本用法
weixin_57190845的博客
07-25 409
java中线程Thread类的基本用法
thread类--线程操作使用细则
m0_49619206的博客
11-08 112
函数名功能thread()：构造一个线程对象，没有关联任何线程函数，即没有启动任何线程：构造一个线程对象，并关联线程函数fn，args1，args2，…为线程函数的参数get_id()：获取线程idjionable()：判断线程是否还在执行，joinable代表的是一个正在执行中的线程。jion()：该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行detach()：在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离的线程变为后台线程，创建的线程的"死活"就与主线程无关。
python线程创建对象_Python多线程编程基础：如何创建线程？
weixin_39639518的博客
11-24 245
Python标准库threading中的Thread类用来创建和管理线程对象，支持使用两种方法来创建线程：1）直接使用Thread类实例化一个线程对象并传递一个可调用对象作为参数；2）继承Thread类并在派生类中重写__init__()和run()方法。创建了线程对象以后，可以调用其start()方法来启动，该方法自动调用该类对象的run()方法，此时该线程处于alive状态，直至线程的run(...
Java实现线程的两种方式
为你灯明三千的博客
02-23 454
在Java中主要提供两种方式实现线程，分别几次java.lang.Thread类与java.lang.Runable接口 一、继承Thread类 从Thread类中实例化的对象代表线程，程序员启动一个新线程建立Thread实例。Thread类中常用的两个构造方法如下： 1、public Thread(String threadName):创建一个名称为threadName的线程对象 2、p...
Java多线程-创建多线程的基本方式一：继承Thread类
最新发布
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
Thread 类及常见方法
weixin_58697177的博客
07-21 1310
系统对于线程的调度是随机的，假设我们的机器上面存在很多的进程和线程，此时 CPU 调度一圈，消耗的时间可能就比较长，此时就可能导致某个线程隔了很久也没有调度上去，这个可能大多数人都遇到过这种情况：某些时候，电脑卡了，点击某个窗口，提示“未响应”，让我们选择等待还是结束进程。此时会出现这样的提示信息，意思是 isQuit 这个变量不是常量或者“实际常量”，常量就是 final 修饰的，“实际常量”是没有final修饰，但是也没有其他代码尝试修改的变量，但是我们在下面对 isQuit 进行了修改，所以不行。
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1964
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
new Thread(()-＞{ xxx.xxx }).start()；的作用
weixin_60170500的博客
09-12 1071
该代码是Java中的一段匿名内部类的使用，用于创建一个新的线程并启动它。具体来说，'new Thread(()->{})' 创建了一个新的线程，并且这个线程的任务是执行括号中的Lambda表达式。所以这个新线程实际上执行了xxx.xxx的任务。'start()'方法则是启动这个新创建的线程。
Java创建线程的方式本质只有一种new Thread
dj1955的博客
08-18 974
线程的生命周期主要有以下六种状态 创建线程方式本质是一种 都是new Thread(**),根据传入的参数类型划分
9中单例模式（优点，缺点，区别，及应用场景）
lzp3033的博客
04-11 253
/* 简介 确保某一个类只有一个对象，而且自行实例化并向系统提供这个实例 这个类称为单例类，它提供全局访问的方法。 单例模式是一种对象创建型模式 基本的实现思路 单例模式要求类能够有返回对象一个引用(永远是同一个)和一个获得该实例的方法 1，私有化该类构造方法。 2，通过new在本类中创建一个本类对象。 3，定义一个公有的方法，将创建的对象返回。 注意事项 单例模式在多线程的应用场合下必须...
JAVA(3)-Thread的5种方法
aggie4628的专栏
07-04 3767
Thread的五种创建方式。 public class ThreadTest { //方法1 调用 new Thread().start(); //方法2 调用 new TT().start(); //方法3 调用 new Thread(new c()).start(); //方法4 JAVA8 lambda表达式 new Thread(()->{}).start()) new Thread(()->{ System.out.
java并发编程 ||Thread生命周期详解
qq_40111437的博客
03-18 913
并发的发展历史 真空管/穿孔打卡 场景：首先把程序按规则写到纸上，穿孔打成卡片，然后把卡片放到输入室并且放到输入设备，专人把卡片的程序写到计算机上，等计算机完成计算以后，会把结果打印输出到打印机上 特点（问题）：计算机大部分时间处于空闲状态，卡片输入之前浪费一大波时间。 晶体管/批处理操作系统 场景：和上面比计算机不需要等待了，可以不断的从磁带机里面拿取磁带，这样就把上面浪费的时...
Thread类的其它方法和属性
m0_63185171的博客
09-11 222
这个东西是给线程起名字,起一个什么样子的名字不影响线程本身的执行,仅仅影响到程序员的调试,可以借助一些工具可以看到每个线程的名字,很容易在调试的时候对线程做出区分,可以用。有两个整数变量,分别对着两个整数变量自增10亿次,分别使用一个线程和两个线程来观察时间的变化。多线程能够提高任务完成的效率,Thread类的其它属性和方法。
【Java多线程】【Thread类及常见方法】
OTO233的博客
07-19 805
Thread类是 JVM用来管理线程的一个类，每个线程都有一个唯一的相关联的Thread对象；每个执行流需要一个对象描述，就是Thread类的对象，JVM讲这些Thread对象组织起来，用于线程调度，线程管理；
Java多线程编程
zjh0101的博客
08-16 387
1，Thread类实现了Runnable接口，所以Thread对象也是可运行Runnable对象，* 同时Thread类也是线程类* Thread类定义* Thread()//一般用于在Thread类中覆盖定义run方法，可以使用匿名内部类进行定义* Thread(Runnable)//使用最多的情况，run方式是由Runnable参数对象提供* Thread(String name) //自定义线程名称* 由于Runnable接口属于函数式接口，所以一般使用简化写法。.........
Java多线程(三)
weixin_41628764的博客
08-18 376
一、线程同步机制 多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作 处理线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步就是一种等待机制。 队列和锁：解决线程安全性 锁机制：synchronized，默认锁的是this，加锁时要注意锁的对象 会引起以下问题： 一个线程持有锁会导致其他所有需要此锁的线程挂起 在多线程竞争下，加锁释放锁会导致比较多的上下文切换和调度延时，引起性能问题； 如果一个优先级高的线程等待一个优先级低的线程释放
Java Thread类详解：构造器、方法与优先级
首先，让我们了解一下Thread类的基本构造器： 1. **Thread()**: 无参构造器，用于创建一个新的线程对象，但没有指定线程名称。当子类没有提供自定义构造器时，系统默认使用此构造器，并通过super()调用父类Thread的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

指挥部在下面

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

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

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

打赏作者

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

抵扣说明：

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

余额充值