Java线程常用方法

最新推荐文章于 2024-07-16 21:06:41 发布
最新推荐文章于 2024-07-16 21:06:41 发布
阅读量209 收藏 2
点赞数 1
文章标签： 多线程 多线程常用方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Quan_qqqq/article/details/86621630
版权

  • .start()方法和run()方法

写一个新的线程的时候，都需要重写run方法。但是重写run方法之后并不代表就创建了新的线程。要想启动一个新的线程必须调用start()方法来启动线程。如果直接调用run方法则并没有新的线程产生。此时的run方法和普通的方法一样。

  • 线程的休眠：sleep()

线程休眠顾名思义就是让线程停止运行一会。

例子：

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<3;i++){
            try {
                // 单位是毫秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt);// 启动线程
        t.start();

    }

}

结果：

Thread-0运行，i = 0
Thread-0运行，i = 1
Thread-0运行，i = 2

结果会每隔一秒出打印一次。

 

  • 当前线程:CurrentThread()

该方法是返回当前正在执行线程的对象的引用。

例：

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        new Thread(mt,"线程1").start() ;        // 启动线程
        mt.run() ;    // 直接调用run()方法
    }

}

结果：因为线程的运行抢到CPU的概率是一样的，所以结果的顺序可能不是一成不变的。

main运行，i = 0
main运行，i = 1
main运行，i = 2
线程1运行，i = 0
线程1运行，i = 1
线程1运行，i = 2

可以看出这里有两个线程一个是主线程，线程名字是main。另一个是我们自己创建的线程，名字是线程1。

“线程1”是我们自己创建的线程，而“main”线程是jvm在启动的时候创建的线程。（jvm在启动的时候不止创建了“main”线程，这里就不介绍了）。并且结果中的main线程是因为直接调用了run方法才打印出来的。也证明了如果直接调用run方法是不会创建新的线程的。而结果中的线程1是我们自己创建的线程，并且用start方法启动之后打印出来的。

 

  • 判断线程是否在执行：isAlive()

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt);// 启动线程
        System.out.println("线程开始之前--------" + t.isAlive());
        t.start();
        System.out.println("线程开始之后--------" + t.isAlive());
        // 让main方法休眠1秒，让创建的线程运行完毕
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程运行完毕之后--------" + t.isAlive());

    }

}

      因为创建的线程比较简单，所以main线程休眠1秒之后很大概率创建的线程就运行完毕了。但是如果创建的线程比较复杂可能1秒就不太够，这里只是做个例子。

结果：

线程开始之前--------false
线程开始之后--------true
Thread-0运行，i = 0
Thread-0运行，i = 1
Thread-0运行，i = 2
线程运行完毕之后--------false

从结果可以很明显的看出，在启动之前该线程是没有在执行的。start之后线程开始执行，执行完毕之后，线程就会销毁所以也是false。

 

  • 线程强制运行：join()

先执行调用该方法的线程，知道运行完毕。

例：

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<30;i++){
            System.out.println(Thread.currentThread().getName()
                    + "线程运行 -->  " + i) ;    // 取得当前线程的名字
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt);// 启动线程
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 10; i++) {
            System.out.println("Main线程运行 --> " + i) ;
        }

    }

}

结果：

Thread-0线程运行 -->  0
Thread-0线程运行 -->  1
Thread-0线程运行 -->  2
Thread-0线程运行 -->  3
Thread-0线程运行 -->  4
Thread-0线程运行 -->  5
Thread-0线程运行 -->  6
Thread-0线程运行 -->  7
Thread-0线程运行 -->  8
Thread-0线程运行 -->  9
Thread-0线程运行 -->  10
Thread-0线程运行 -->  11
Thread-0线程运行 -->  12
Thread-0线程运行 -->  13
Thread-0线程运行 -->  14
Thread-0线程运行 -->  15
Thread-0线程运行 -->  16
Thread-0线程运行 -->  17
Thread-0线程运行 -->  18
Thread-0线程运行 -->  19
Thread-0线程运行 -->  20
Thread-0线程运行 -->  21
Thread-0线程运行 -->  22
Thread-0线程运行 -->  23
Thread-0线程运行 -->  24
Thread-0线程运行 -->  25
Thread-0线程运行 -->  26
Thread-0线程运行 -->  27
Thread-0线程运行 -->  28
Thread-0线程运行 -->  29
Main线程运行 --> 0
Main线程运行 --> 1
Main线程运行 --> 2
Main线程运行 --> 3
Main线程运行 --> 4
Main线程运行 --> 5
Main线程运行 --> 6
Main线程运行 --> 7
Main线程运行 --> 8
Main线程运行 --> 9

 

 

  • 线程的中断：interrupt()

一个线程可以被另一个线程中断其操作的状态，使用 interrupt（）方法完成。

class Thread1 implements Runnable{

    @Override
    public void run() {

        System.out.println("1.-------进入run方法");

        try {
            Thread.sleep(10000);
            System.out.println("2.-------线程休眠结束");
        } catch (InterruptedException e) {
            System.out.println("3.-------线程休眠终止");
            // 如果不加"4.-------线程正常结束"就会打印出来，但是线程并不是正常结束的。
            return;
        }
        System.out.println("4.-------线程正常结束");
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt);// 启动线程
        t.start();
        try{
            Thread.sleep(2000) ;    // 线程休眠2秒
        }catch(InterruptedException e){
            System.out.println("3、休眠被终止") ;
        }
        t.interrupt() ;    // 中断线程执行

    }

}

结果：

1.-------进入run方法
3.-------线程休眠终止

 

 

  • 后台线程：setDaemon()

将此线程标记为守护线程或用户线程。 当运行的线程都是守护进程线程时，Java虚拟机将退出。

class Thread1 implements Runnable{

    @Override
    public void run() {
        int i=0;
        //设置死循环，这样来实现线程不断运行，设置后台运行。
        while(true){
            System.out.println(Thread.currentThread().getName() + "在运行。"+i) ;
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 mt = new Thread1() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");// 启动线程
        t.setDaemon(true) ;    // 此线程在后台运行
        t.start() ;    // 启动线程

    }

}

此时创建的线程不会一直运行，而是主线程结束之后，该线程也会结束运行。

 

  • 线程的优先级：getPriority()

返回此线程的优先级。

优先级分为最低，最高，普通三个（Thread.MIN_PRIORITY，Thread.MAX_PRIORITY，Thread.NORM_PRIORITY）

设置优先级为：setPriority（）

例：

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            try{
                Thread.sleep(500) ;    // 线程休眠
            }catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Thread1(),"线程A") ;    // 实例化线程对象
        Thread t2 = new Thread(new Thread1(),"线程B") ;    // 实例化线程对象
        Thread t3 = new Thread(new Thread1(),"线程C") ;    // 实例化线程对象
        t1.setPriority(Thread.MIN_PRIORITY) ;    // 优先级最低
        t2.setPriority(Thread.MAX_PRIORITY) ;    // 优先级最高
        t3.setPriority(Thread.NORM_PRIORITY) ;    // 优先级一般
        t1.start() ;    // 启动线程
        t2.start() ;    // 启动线程
        t3.start() ;    // 启动线程
    }

}

结果：

线程C运行，i = 0
线程A运行，i = 0
线程B运行，i = 0
线程C运行，i = 1
线程B运行，i = 1
线程A运行，i = 1
线程A运行，i = 2
线程C运行，i = 2
线程B运行，i = 2
线程B运行，i = 3
线程C运行，i = 3
线程A运行，i = 3
线程B运行，i = 4
线程A运行，i = 4
线程C运行，i = 4

主方法的优先级：

    public static void main(String args[]){
        System.out.println("主方法的优先级：" + 
            Thread.currentThread().getPriority()) ;    // 取得主方法的优先级
        System.out.println("MAX_PRIORITY = " + Thread.MAX_PRIORITY) ;
        System.out.println("NORM_PRIORITY = " + Thread.NORM_PRIORITY) ;
        System.out.println("MIN_PRIORITY = " + Thread.MIN_PRIORITY) ;
    }
主方法的优先级：5
MAX_PRIORITY = 10
NORM_PRIORITY = 5
MIN_PRIORITY = 1

由此可知，主方法优先级是5，也就是普通优先级，而且主方法是一个线程对象。

 

  • 线程的礼让：yield()

例：

class Thread1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            try{
                Thread.sleep(500) ;//休眠一下
            }catch(Exception e){}
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
            if(i==2){
                System.out.print("线程礼让：") ;
                Thread.currentThread().yield() ;    // 首先获取当前线程，然后线程礼让
            }
        }
    }
}

public class ExerciseDemo1 {

    public static void main(String[] args) {
        Thread1 my = new Thread1() ;    // 实例化MyThread对象
        Thread t1 = new Thread(my,"线程A") ;
        Thread t2 = new Thread(my,"线程B") ;
        t1.start() ;
        t2.start() ;
    }

}

 

结果：

线程A运行，i = 0
线程B运行，i = 0
线程B运行，i = 1
线程A运行，i = 1
线程B运行，i = 2
线程A运行，i = 2
线程礼让：线程礼让：线程A运行，i = 3
线程B运行，i = 3
线程A运行，i = 4
线程B运行，i = 4

 

Quan_qqqq
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中线程常用的方法
weixin_42408447的博客
12-13 740
1. sleep() Thread.sleep(1000) 在指定时间内让当前执行的线程暂停执行一段时间，让其他线程有机会继续执行，但不会释放对象锁，也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据，不推荐使用。sleep() 使当前线程进入阻塞状态，在指定时间不会执行，因此sleep()方法常用来暂停线程的执行，当sleep()结束后，然后转入到 Runnable(就绪状态)，这样才能够得到执行的机会。 注意是让当前的线程睡眠一段时间 2.yield() Thread.yie
Java 线程常用方法总结
06-26
Java线程是并发编程的核心部分，它允许程序同时执行多个任务。在Java中，线程的创建和管理涉及几个关键方法以及一个关键字：`run()`, `start()`, `wait()`, `notify()`, `notifyAll()`, `sleep()`, `yield()`, `join...
JAVA中多线程的常用方法
qq_42843172的博客
07-08 119
JAVA中多线程的常用方法 获取当前线程对象 Thread currentThread = Thread.currentThread(); 获取线程对象的名字 String .getName() 修改线程对象的名字 .setName(" ") 默认线程名字： Thread-0 Thread-1 Thread-2 … public class ThreadTest05 { public static void main(String[] args) { //返回当
学习日志：java线程
最新发布
weixin_46117680的博客
07-16 947
这里总结线程的一些概念以及使用。
java线程中的若干重要方法
cesium的专栏
05-18 3052
run():线程的执行逻辑start():启动线程yield():暂定线程的执行，允许其它线程竞争CPU，常用于具有同等优先级的线程之间的竞争，适用于不支持时间分片的操作系统之间的线程处理。sleep（long millis）:线程休眠，暂停执行，但是不交出临界区的锁。stop（）:kill一个线程，但是通常通过线程内的循环条件来结束一个线程。setPriority(int w
Java 线程常用方法
m0_57015193的博客
06-01 389
Java 线程常用方法有以下几种： Object 方法： wait() notify() notifyAll() 静态方法： yield() sleep() currentThread() 非静态方法： start() run() join() getState() interrupt() isInterrupted()
Java 线程常用方法
Happy_syy的博客
08-23 414
1.join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 import java.util.Date; public class Program { public static void main(String[] args) { TimeThread timeThread = new TimeThread(); timeThread.start...
关于多线程常用方法以及对锁的控制(详解)
08-30
多线程常用方法以及对锁的控制详解 多线程编程是Java编程中的一种重要技术，能够提高程序的执行效率和响应速度。但是，多线程编程也带来了许多挑战，如线程安全、锁的控制等。本文将详细介绍多线程常用方法以及对锁...
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
本文将深入探讨Java中用于线程唤醒与阻塞的常用方法，以及它们在实际编程中的应用。 1. **线程的阻塞** - `wait()`: 这个方法属于`Object`类，当一个线程调用对象的`wait()`方法时，它会释放该对象的锁并进入等待...
java线程池常用方法.docx
06-12
### Java线程池常用方法详解 #### 一、引言 自Java 5引入并发包`java.util.concurrent`以来，线程的管理与控制变得更为高效与便捷。在这个包中，`Executor`框架成为了线程管理和调度的核心。通过`Executor`，我们...
DemoUtil.zip_java常用工具方法
09-23
"DemoUtil.zip"这个压缩包中包含了一个名为"DemoUtil.java"的文件，这很可能是一个包含了各种Java常用工具方法的类。以下将详细介绍可能包含在这个类中的知识点。 1. **集合操作**：在Java开发中，集合框架（如...
Java：线程常用方法
龙雪的博客
11-09 350
join方法   join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。       注：当循环执行到i为2时该行代码执行，CounterThread所创建线程进入阻塞状态，直到timeThread变量所对应线程结束，    CounterThread所创建线程才能再次进入就绪状态，进而进入执行状态。   注意： 线程对象在调...
【Java】线程常用方法
兮动人
04-08 754
1. 线程常用方法 setName 设置线程名称，使之与参数name相同 getName 返回该线程的名称 start 使该线程开始执行；Java虚拟机底层调用该线程的start0方法 run 调用线程对象run方法; setPriority 更改线程的优先级 getPriority 获取线程的优先级 sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行) interrupt 中断线程 2. 注意事项和细节 start：底层会创建新的线程，调用run，run 就是一个简单的方法调用，不会启
【Java】 线程的常用方法
dengmsjava的博客
04-20 1967
线程的常用方法 (1) setName：设置线程名称，使之与参数name相同； (2) getName：返回该线程的名称； (3) start：使该线程开始执行，Java虚拟机底层调用该线程的start0( )方法； (4) run：调用线程对象run方法。start底层会创建新的线程，run是一个简单的方法调用，不会启动新线程。 (5) setPriority：更改线程的优先级； (6) getPriority：获取线程的优先级； (7) sleep：在指定的毫秒数内让当前正在执行的线程休眠；
Java线程常见方法
huing的博客
07-20 160
的线程抛出InterruptedException，并清除打断标。如果被打断线程正在sleep，wait，join会导致被打断。线程启动后会调用Runnable中的run方法，否则默。java中规定线程优先级是1~10的整数，较大的优先级。start方法只是让线程进入就绪，里面代码不一定立刻。start方法只能调用一次，如果调用了多次会出现。如果打断的正在运行的线程，则会设置打断标。park的线程被打断，也会设置打断标记。能提高该线程被CPU调度的机率。主要是为了测试和调试。...
JAVA 线程常用方法
Logicr的博客
06-17 415
时人不识凌云木，直待凌云始道高。 —杜荀鹤《小松》 - - sleep（） 线程休眠 yield（） 线程让步 join（） 等待该线程 stop（） 线程停止，可能导致数据截断等 interrupt（） 中断线程，不会终止正在执行的线程。 wait（） 线程等待（synchronized下） ...
java 多线程常用方法
02-23
Java中多线程常用的方法有以下几种： 1. 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法，在run()方法中定义线程要执行的任务。然后通过创建子类的对象，调用start()方法启动线程。 2. 实现Runnable接口：创建一个实现了Runnable接口的类，并实现其run()方法，在run()方法中定义线程要执行的任务。然后通过创建该类的对象，将其作为参数传递给Thread类的构造方法，再调用start()方法启动线程。 3. 使用Callable和Future：Callable接口是一种带有返回值的线程，通过实现Callable接口并实现其call()方法来定义线程要执行的任务。然后使用ExecutorService的submit()方法提交Callable任务，并返回一个Future对象，通过Future对象可以获取线程执行的结果。 4. 使用线程池：通过Executor框架提供的线程池来管理线程的创建和执行。可以使用Executors类提供的静态方法创建不同类型的线程池，然后将任务提交给线程池执行。 5. 使用synchronized关键字：通过在方法或代码块前加上synchronized关键字来实现线程同步，保证多个线程对共享资源的访问是互斥的。 6. 使用Lock接口：Lock接口提供了比synchronized更灵活和强大的线程同步机制。通过Lock接口的lock()和unlock()方法来实现对共享资源的加锁和解锁。 7. 使用wait()、notify()和notifyAll()方法：通过Object类提供的wait()、notify()和notifyAll()方法来实现线程间的通信和协作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值