多线程Tread中的常用方法

Java多线程：常用方法解析
最新推荐文章于 2024-03-30 13:04:53 发布
原创 最新推荐文章于 2024-03-30 13:04:53 发布 · 572 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #thread

本文介绍了Java中多线程的常用方法，包括start()启动线程、run()执行任务、currentThread()获取当前线程、getName()和setName()操作线程名，以及yield()、join()和sleep()等线程控制方法。通过实例解析了这些方法的使用和作用。

多线程的方法

Tread中常用的方法
  1. start()：启动当前线程；调用当前线程的run()
  2. run()：通常需要重写Thread类中的方法，将创建的线程要执行的操作声明在此方法中
  3. currentThread()：静态方法，返回执行当前代码的线程
  4. getName()：获取当前线程的名字
  5. setName()：设置当前线程的名字
  6. yield()：释放当前cpu的执行
  7. join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，知道线程b完全执行完以后，线程a才结束阻塞状态。
  8. stop()：已过时。当执行此方法时，强制结束当前线程。
  9. sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  10. isAlive()：判断当前线程是否存活
package new1;

/*
* 多线程的创建，方式一：继承Thread类
* 1.创建一个继承于Thread类的子类
* 2.重写Thread类的run（）--->将此线程执行的操作声明在run（）中
* 3.创建Thread类的子类的对象
* 4.通过此对象调用start（）
*
* 例子：遍历100以内的所有偶数
* */


//1.创建一个继承于Thread类的子类
class MyThread1 extends Thread {
    //2.重写Thread类的run（）
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class MyThread2 extends Thread {
    //2.重写Thread类的run（）
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class demo1{
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();//在启动一个线程，需要重新创建一个线程对象


        //4.通过此对象调用star();先启动当前线程，然后调用当前线程的run()
        t1.start();
        t2.start();
        for (int i = 20; i < 40; i++){
            if(i%2 != 0){
                System.out.println("这是主线程："+i);
            }
        }

    }
}

结果

这是主线程：21
这是主线程：23
Thread-1:1
Thread-1:3
Thread-1:5
Thread-1:7
Thread-1:9
Thread-1:11
Thread-1:13
Thread-1:15
Thread-1:17
Thread-1:19
Thread-0:0
Thread-0:2
Thread-0:4
Thread-0:6
Thread-0:8
Thread-0:10
Thread-0:12
Thread-0:14
Thread-0:16
Thread-0:18
这是主线程：25
这是主线程：27
这是主线程：29
这是主线程：31
这是主线程：33
这是主线程：35
这是主线程：37
这是主线程：39

匿名子类的方式

package new1;

public class demo2 {
    public static void main(String[] args) {
        //创建Thread的匿名子类的方式
        new Thread() {
            public void run() {
                for (int i = 0; i < 20; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                for (int i = 0; i < 20; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}

答案

Thread-0:0
Thread-0:2
Thread-0:4
Thread-0:6
Thread-0:8
Thread-0:10
Thread-0:12
Thread-0:14
Thread-0:16
Thread-0:18
Thread-1:1
Thread-1:3
Thread-1:5
Thread-1:7
Thread-1:9
Thread-1:11
Thread-1:13
Thread-1:15
Thread-1:17
Thread-1:19
命名，获取名，与currentThread()
package new1;

public class demo2 {
    public static void main(String[] args) {
        MyThread3 h1 = new MyThread3();
        h1.setName("线程一");
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class MyThread3 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

答案

主线程:1
线程一:0
线程一:2
线程一:4
线程一:6
线程一:8
线程一:10
线程一:12
线程一:14
线程一:16
线程一:18
主线程:3
主线程:5
主线程:7
主线程:9
主线程:11
主线程:13
主线程:15
主线程:17
主线程:19
另一种命名方式（利用Thread类中的构造方法命名）
package new1;

public class demo2 {
    public static void main(String[] args) {
        MyThread3 h1 = new MyThread3("线程一一");
        //h1.setName("线程一");
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class MyThread3 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

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

答案

线程一一:0
线程一一:2
线程一一:4
主线程:1
线程一一:6
主线程:3
主线程:5
线程一一:8
主线程:7
主线程:9
主线程:11
主线程:13
主线程:15
主线程:17
主线程:19
线程一一:10
线程一一:12
线程一一:14
线程一一:16
线程一一:18
yield方法
package new1;

public class demo2 {
    public static void main(String[] args) {
        MyThread3 h1 = new MyThread3("线程一一");
        //h1.setName("线程一");
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class MyThread3 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i%4 == 0){
                yield();  //yield方法
            }
        }
    }

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

答案

主线程:1
线程一一:0
主线程:3
线程一一:2
主线程:5
线程一一:4
主线程:7
主线程:9
主线程:11
主线程:13
主线程:15
主线程:17
主线程:19
线程一一:6
线程一一:8
线程一一:10
线程一一:12
线程一一:14
线程一一:16
线程一一:18

join方法

package new1;

public class demo2 {
    public static void main(String[] args) {
        MyThread3 h1 = new MyThread3();
        h1.setName("线程一");
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if( i== 1){
            try {                        
                h1.join();    //jion方法＋异常处理
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
        }
    }
}

class MyThread3 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

}
sleep
package new1;

public class demo2 {
    public static void main(String[] args) {
        MyThread3 h1 = new MyThread3();
        h1.setName("线程一");
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
           
        }
    }
}

class MyThread3 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(1000);      //sleep方法，强制休息一秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
【JAVA】-- 多线程Thread类的常用方法
个人博客
05-17 1万+
一、Thread类的常用方法 1、start（）：启动当前线程 2、run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作写在此方法中。 3、currentThread（）：静态方法，返回执行当前代码的线程 4、getName（）：获取当前线程的名字，与3一起使用可得到正在执行的线程的名字 5、setName（）：设置当前线程的名字 6、yield（）：释放当前cpu的执行权 7、join（）：在线程a中调用线程b的join（）；此时线程a就进入阻塞状态，直到线程b完全执行
Qt基础-QThread多线程详解
qq_30725967的博客
03-05 1016
本文详解Qt的QThread多线程，实例演示两种使用方式。
多线程-Thread类及常见方法
weixin_71841320的博客
01-20 1450
Thread类是Java编程语言中的一个重要类，用于支持多线程编程。它是java.lang包中的一部分，提供了创建和管理线程的方法和功能。通过使用Thread类，可以同时执行多个任务，实现并行处理。每个线程都有独立的执行路径，可以在不同的时间段内独立运行。这使得程序能够更高效地利用计算机的资源，并提高应用程序的响应速度。Thread类提供了许多方法来管理线程的行为，例如start()方法用于启动线程，join()方法用于等待线程的结束，sleep()方法用于暂停线程的执行等等。
Thread类常用方法
weixin_30302609的博客
03-03 361
Thread类构造方法： 1.Thread（）； 2.Thread（String name）； 3.Thread（Runable r）； 4.Thread（Runable r, String name）； [java]view plaincopy publicclassTest{ publicstaticvoidm...
Java中Thread类的方法简介
热门推荐
PetrichorKe
06-05 1万+
1.新建线程 Thread t1 = new Thread(); t1.start(); 新建线程，应该调用start()方法启动线程；如果直接调用run()方法，该方法也会执行，但会被当做一个普通的方法，在当前线程中顺序执行；而如果使用start()方法，则会创建一个新的线程执行run()方法。 2.线程中断 public void interrupt(); public boole...
多线程(Thread)
CDZAllier的博客
08-05 1744
程序 ： 是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。 进程： 是程序在处理机上的一次执行过程，它是一个动态的概念。（独立运行的程序，也就是处理机执行的过程） 进程的三种状态： 1)就绪状态(Ready)2)运行状态(Running)3)阻塞状态(Blocked) 线程：（java是多线程） 线程是进程的划分，（也就是进程中的一个执行路径，共享一个空间，...
Thread类的有关方法
qq_46112274的博客
06-05 4283
多线程
讲解实际业务场景中tread，和其他线程的用法，包括多种创建线程的方式，线程中常用的方法，参数介绍，另外单独讲清楚线程池的使用，都需要结合实际业务场景，详细输出
最新发布
07-08
在 Java 的实际业务开发中，**多线程** 是提高系统并发性能的重要手段。通过合理使用线程和线程池，可以提升系统的响应速度、资源利用率以及任务调度的灵活性。 --- ## 一、Java 中创建线程的方式（结合业务场景）...
C# Tread浅析
08-18
在.NET框架中，`System.Threading`命名空间提供了`Thread`类用于处理多线程编程。通过使用`Thread`类，开发者可以轻松地创建并管理多个并发执行的任务，这对于提高程序性能以及实现复杂的业务逻辑具有重要意义。 ##...
thread 类的常用方法
qq_45068048的博客
10-09 626
package 练习; import javax.swing.*; /* 1.thread类的方法: 2.start:启动线程的方法 3.run:继承thread类重写run方法； 4.thread.currentThread. setname：设置线程名(也可用对象名.setname方法) getname：获取线程名 5.同样可以通过构造方法设置线程名 6.yield:方法 释放当前cpu使用权 但下一次可能还会是当前线程 7.join方法 线程a中调用了线程b 的join方法，此时线程a 进入阻
Thread 类及常见方法
2201_75437633的博客
03-30 1197
引言：Thread 类是 JVM ⽤来管理线程的⼀个类，换句话说，每个线程都有⼀个唯⼀的 Thread 对象与之关联。每个执⾏流，也需要有⼀个对象来描述，⽽ Thread 类的对象 就是⽤来描述⼀个线程执⾏流的，JVM 会将这些 Thread 对象组织起来，⽤于线程调度，线程管理。
Thread类的常用方法
chenchenchencl的博客
12-05 3152
Thread类的常用方法
【多线程】Thread 类及常见方法
m0_60494863的博客
05-14 6167
1.Thread 类 在Java标准库中，提供有一个Thread,来表示/操作线程。 Thread 类也可以视为Java 标准库提供的API。 创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。 操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类 2.创建线程 2.1继承Thread 类 通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法 （1）继承Thread 来创建一
【JavaEE】线程的创建及常见方法解析（Tread类）
努力
03-21 1342
线程的创建及常见方法解析
Thread 类的基本用法【JavaEE】
m0_72161237的博客
03-15 731
📖java 在进行多线程编程时，java标准库提供了一个类 Thread 能够表示一个线程。 1️⃣创建线程2️⃣启动一个线程————start()3️⃣中断线程4️⃣等待一个线程-join()5️⃣线程休眠6️⃣获取当前线程引用7️⃣线程的状态
学习笔记（4）：java中Thread类常用方法
weixin_44663273的博客
04-25 712
Thread类常用方法1、Thread.sleep(time)：延时2、thread.join()：插队3、Thread.getState()：监控线程状态4、thread.getPriority()线程优先级5、thread.setDaemon(Boolean)线程守护 1、Thread.sleep(time)：延时 /** * @title: MyTimer * @projectName ...
Java Tread多线程（2）多线程安全问题
机器学习
09-17 2537
本文演示，Tread多线程安全问题，以及几种解决多线程安全方式。 1）一个线程不安全的Demo 2）线程同步（synchronized，函数同步，this锁，Class对象锁） 一、小Demo演示引出线程安全问题： 二、线程同步 问题：对于上面的问题，我们是不是可以采取一个这样的措施？当线程1执行run代码段的时候，我们不让其他的线程来执行，直到线程1执行完，其他的线程才可以进入。 解决方案：好在Java里面本来就有这样的函数，将代码段包裹起来，就可以达到上面问题描述的效果。函数名：synchronized
Java并发编程：Tread类的使用（二）
oooooooooooooookjk的博客
08-06 288
具体了解几个概念 线程的状态 创建new 就绪 runnable 运行running 阻塞blocked timewaiting waiting 消亡（dead） 线程创建后不会立即进入就绪状态，因为线程运行需要一些条件，比如内存资源，JVM区域划分（程序计数器，java栈，本地方法栈都是线程私有的），当线程进入就绪状态后不代表能立刻获得CPU的执行时间. 上下文切换 cpu在一个...
java Tread中断方法
01-08
在Java中，`interrupt()` 方法用于请求中断线程。然而，此方法不会强制终止线程；相反，它设置了一个中断标志位来通知目标线程应该停止其当前活动[^1]。 当一个线程被标记为已中断时，在该线程调用 `Thread.sleep()...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值