Java：线程常用方法

最新推荐文章于 2024-03-30 10:30:00 发布
最新推荐文章于 2024-03-30 10:30:00 发布
阅读量190 收藏
点赞数
原文链接：https://blog.csdn.net/dragongiri/article/details/83903563
版权

join方法

 

join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。

注：当循环执行到i为2时该行代码执行，CounterThread所创建线程进入阻塞状态，直到timeThread变量所对应线程结束，    CounterThread所创建线程才能再次进入就绪状态，进而进入执行状态。

注意：

线程对象在调用join方法前必须先调用start方法，否则该线程永远不会进入执行状态。

interrupt方法

 

interrupt方法：

结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态，并在调用wait、join和sleep方法处产生InterruptedException异常。

注：理论上beforeTime和afterTime应该相差30秒，但因为该线程类的对象在1秒后执行了interrupt方法而使得该线程对象提前结束了阻塞状态，从而导致了beforeTime和afterTime相差少于30秒

注：当线程执行该行代码后，线程进入阻塞状态；但由于10秒后主线程执行了“counterThread.interrupt();”代码使得该线程阻塞状态结束。该行代码的执行会结束counterThread线程的阻塞状态。

wait()—痴汉方法

wait()方法就是使线程停止运行，会释放对象锁。

wait（）方法是从运行态回阻塞态。
notifi( ) 方法是从阻塞态回运行态。

    wait（）方法会使当前线程调用该方法后进行等待，并且将该线程置入锁对象的等待队列中，直到接到通知或被中断为止。
    wait()方法只能在同步方法或同步代码块中调用，如果调用wait（）时没有适当的锁，会抛出异常。
    wait()方法执行后，当前线程释放锁，其他线程可以竞争该锁。

    wait()之后的线程继续执行有两种方法：

    调用该对象的notify（）方法唤醒等待线程。
    线程等待时调用interrupt（）中断该线程。

wait(long time) ：如果到了预计时间还未被唤醒，线程将继续执行。

class MyThread implements Runnable{
    private Object object;
    private boolean flag;

    public MyThread(Object object, boolean flag) {
        this.object = object;
        this.flag = flag;
    }

    public void waitMethod() {
        synchronized (object) {
            System.out.println("wait方法开始..." + Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束..." + Thread.currentThread().getName());
        }
    }
    public void notifyMethod(){
        synchronized (object) {
            System.out.println("notify方法开始..." + Thread.currentThread().getName());
            object.notify();
            System.out.println("notify方法结束..." + Thread.currentThread().getName());
        }
    }
    public void run(){
        if(flag){
           this.waitMethod();
        }else{
           this.notifyMethod();
        }
    }
}
public class Object {
    public static void main(String[] args)throws InterruptedException{
        Object obj = new Object();
        MyThread thread1 = new MyThread(obj,true);
        MyThread thread2 = new MyThread(obj,false);
        Thread waitThread = new Thread(thread1,"等待线程");
        Thread notifyThread = new Thread(thread2,"唤醒线程");
        waitThread.start();
        Thread.sleep(1000);
        notifyThread.start();
    }
}

运行结果：
wait方法开始...等待线程
notify方法开始...唤醒线程
notify方法结束...唤醒线程
wait方法结束...等待线程
 

2. notify（）方法

  1. notify（）方法必须在同步方法或同步代码块中调用，用来唤醒等待在该对象上的线程，如果有多个线程等待，则任意挑选一个线程唤醒。
  2. notify（）方法执行后，唤醒线程不会立刻释放锁，要等唤醒线程全部执行完毕后才释放对象锁。

  3. class MyThread implements Runnable{
        private Object object;
        private boolean flag;

        public MyThread(Object object, boolean flag) {
            this.object = object;
            this.flag = flag;
        }

        public void waitMethod() {
            synchronized (object) {
                System.out.println("wait方法开始..." + Thread.currentThread().getName());
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("wait方法结束..." + Thread.currentThread().getName());
            }
        }
        public void notifyMethod(){
            synchronized (object) {
                System.out.println("notify方法开始..." + Thread.currentThread().getName());
                object.notify();
                System.out.println("notify方法结束..." + Thread.currentThread().getName());
            }
        }
        public void run(){
            if(flag){
               this.waitMethod();
            }else{
               this.notifyMethod();
            }
        }
    }
    public class Object {
        public static void main(String[] args)throws InterruptedException{
            Object obj = new Object();
            MyThread thread1 = new MyThread(obj,true);
            MyThread thread2 = new MyThread(obj,false);
            for(int i = 0;i<5;i++) {
                Thread threadi = new Thread(thread1, "等待线程"+i);
                threadi.start();
            }
            Thread notifyThread = new Thread(thread2,"唤醒线程");
            Thread.sleep(1000);
            notifyThread.start();
        }
    }
    wait方法开始...等待线程0
    wait方法开始...等待线程1
    wait方法开始...等待线程2
    wait方法开始...等待线程3
    wait方法开始...等待线程4
    notify方法开始...唤醒线程
    notify方法结束...唤醒线程
    wait方法结束...等待线程0
    //当有多个线程同时等待时，notify方法任意挑选一个唤醒。
     

 

wait（）和notify（）均用于同步方法或同步代码块并且必须是内建锁。

3. notifyAll()

唤醒所有在该对象上等待的线程。

class MyThread implements Runnable{
    private Object object;
    private boolean flag;

    public MyThread(Object object, boolean flag) {
        this.object = object;
        this.flag = flag;
    }

    public void waitMethod() {
        synchronized (object) {
            System.out.println("wait方法开始..." + Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束..." + Thread.currentThread().getName());
        }
    }
    public void notifyMethod(){
        synchronized (object) {
            System.out.println("notify方法开始..." + Thread.currentThread().getName());
            object.notifyAll();
            System.out.println("notify方法结束..." + Thread.currentThread().getName());
        }
    }
    public void run(){
        if(flag){
           this.waitMethod();
        }else{
           this.notifyMethod();
        }
    }
}
public class Object {
    public static void main(String[] args)throws InterruptedException{
        Object obj = new Object();
        MyThread thread1 = new MyThread(obj,true);
        MyThread thread2 = new MyThread(obj,false);
        for(int i = 0;i<5;i++) {
            Thread threadi = new Thread(thread1, "等待线程"+i);
            threadi.start();
        }
        Thread notifyThread = new Thread(thread2,"唤醒线程");
        Thread.sleep(1000);
        notifyThread.start();
    }
}
运行结果：
wait方法开始...等待线程0
wait方法开始...等待线程1
wait方法开始...等待线程2
wait方法开始...等待线程3
wait方法开始...等待线程4
notify方法开始...唤醒线程
notify方法结束...唤醒线程
wait方法结束...等待线程4
wait方法结束...等待线程3
wait方法结束...等待线程2
wait方法结束...等待线程1
wait方法结束...等待线程0
 

 

setDaemon方法

 

setDaemon方法：用于将一个尚未调用线程start方法的线程设置为守护线程。守护线程主要用于为其他线程的运行提供服务（Java中的垃圾回收机制就是守护线程），这种线程属于创建它的线程，守护线程随着主线程的终止而终止。

注：守护线程不是将原来线程改为守护线程，而是本来就是守护线程，别忘了setDaemon方法需要在start方法之前调用。设置本线程为守护线程。

 

注意：

线程中所启动的其他非守护线程线程不会随着该线程的结束而结束。（参见代码2）

 

currentThread方法

 

currentThread方法：返回当前正在执行的线程对象。

注：返回正在执行main方法的线程对象——主线程

 

注意：

请判读备注中代码1、代码2、代码3和代码4。

注：通过运行结果可以发现此方法被一个名为“时间线程”的线程执行

isAlive方法

 

isAlive方法：判定该线程是否处于就绪、运行或阻塞状态，如果是则返回true，否则返回false。

注：当打印线程阻塞时程序一定会先执行main方法中的输出语句，此时输出true；当打印线程阻塞状态结束，此时输出false，由此可见main方法中启动的线程可能晚于主线程结束。

 

其它方法

 

1.void start()：使该线程开始启动，Java 虚拟机负责调用该线程的 run() 方法。多次启动一个线程是非法的。

 

2.void sleep(long millis)：Thread类静态方法，线程进入阻塞状态，在指定时间（单位为毫秒）到达之后进入就绪状态（Runnable），而非立即进入执行状态。

 

3.void yield()：静态方法，当前线程放弃占用CPU资源，回到就绪状态，使其他优先级不低于此线程的线程有机会被执行。

 

4.void setPriority(int newPriority)：设置当前线程的优先级，线程优先级越高，线程获得执行的次数越多，Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

 

①static int MAX_PRIORITY   最高优先级值为10；

 

②static int NORM_PRIORITY   默认优先级值为5；

 

③static int MIN_PRIORITY   最低优先级值为1；

 

5.int getPriority()：获得当前线程的优先级。
终止线程——无疾而终

终止线程——暴毙身亡

注：巧妙利用线程对象调用interrupt方法时会引发异常而使得死循环中止

注：巧妙利用线程对象调用interrupt方法时会引发异常而使得死循环中止

4.线程阻塞

    调用sleep（）方法，主动放弃占有的CPU，不会释放对象锁。
    调用阻塞式IO方法（read()、write()），在该方法返回前，线程阻塞。
    线程试图获取一个monitor，但该monitor被其他线程所持有导致阻塞。
    线程等待某个通知，即调用wait()，释放对象锁。
    调用线程suspend（），将线程挂起，容易导致死锁，已被废弃。
    这五个线程会从运行状态到阻塞状态。

5. monitor 的两个队列

每个monitor都有两个队列，一个称为同步队列，一个称为等待队列。

    同步队列中存放了因为竞争monitor失败导致阻塞的线程，这些线程等待CPU调度再次竞争锁。
    等待队列存放所有调用wait()方法导致线程等待的线程，唤醒后进入同步队列竞争锁。
 

 

jenybom
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程类的常见方法
最自由的笑的博客
08-09 1168
介绍线程类常用方法 start方法： 让一个线程进入就绪状态 run方法：线程真正要执行的逻辑，让一个线程分配的cpu资源，开始启动就会调用run方法执行 sleep(n)方法：让线程休眠n毫秒，休眠时会让出cpu但不会释放锁。 join方法：当前线程等待目标线程运行结束，再开始运行。可以设置超时时间 interrupt()方法：打断线程，如果打断正在sleep，wait，join的方法会抛出InterruptedException异常，并清除打断标记。 如果打断正在执行的线程，会设置打
Java中线程常用的方法
weixin_42408447的博客
12-13 733
1. sleep() Thread.sleep(1000) 在指定时间内让当前执行的线程暂停执行一段时间，让其他线程有机会继续执行，但不会释放对象锁，也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据，不推荐使用。sleep() 使当前线程进入阻塞状态，在指定时间不会执行，因此sleep()方法常用来暂停线程的执行，当sleep()结束后，然后转入到 Runnable(就绪状态)，这样才能够得到执行的机会。 注意是让当前的线程睡眠一段时间 2.yield() Thread.yie
线程常见的几种方法
这个人很懒，什么都没有留下。
11-13 4844
Thread静态方法 1. Thread.sleep(misseconeds) 睡眠：当前线程暂停一段时间让给别的线程去运行。Sleep复活时间，根据你传入的睡眠时间而定，等到睡眠到规定的时间后，线程自动复活，它不会释放锁资源。2. Thread.yield（） 让当前正在执行线程停下来一下，把执行机会让给别的在等待的线程，自己回到等待的就绪队列里面，自己也有可能会运行到，但更大的机会是让别的等待线程运行，相当于将自己的优先级暂时降低一下，把机会让给别人一会儿。 Thread实例方法 1. start
总结线程常用方法
m0_46383618的博客
02-05 1572
目录 一、join方法 二、interrupt方法 三、currentThread方法 四、isAlive方法 五、setDaemon方法 六、其它方法 七、终止线程——无疾而终 八、终止线程——暴毙身亡 一、join方法 join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 注意： 线程对象在调用join方法前必须先调用start方法，否则该线程永远不会进入执行状态。 二、interrupt方法 interrupt方法：结束线程
【面试常问】线程中常用的方法
Willing卡卡的博客
02-12 1520
在我们日常开发中线程是必不可少的，那么线程中的方法也就成了面试中的高频问题，决定整理一下；如有错误还请个位指正！
线程使用的六大常用方法！
Rocky_monkey的博客
05-20 1045
本篇讲述线程使用的六大常用方法：sleep()、join()、yield()、setDaemon()、setPriority () & getPriority()、getState() 方法一：sleep() 使线程停止运行一段时间，将处于阻塞状态 如果调用了sleep方法之后，没有其他等待执行的线程，这个时候当前线程不会马上恢复执行! 之前我们用sleep() 模拟了网络延时，可以放...
5、Java 线程类常用方法
meiyongdesan的博客
06-06 468
概述 线程在运行过程中可以通过调用方法来修改状态和属性。本篇我们主要介绍 Java 线程常见的方法 Java 线程常见方法 本篇我打算从以下三种类型出发，依次介绍常见的线程方法： 实例方法 静态方法 Object() 继承方法 1、实例方法 2、静态方法 Java 线程类常见的静态方法有以下这些： currentThread() yield() sleep() 2-1、currentThread() public static native Thread currentThread();
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
- Java线程有10个优先级，`Thread.MIN_PRIORITY`(1)到`Thread.MAX_PRIORITY`(10)，默认优先级为`Thread.NORM_PRIORITY`(5)。不过，线程优先级并不保证执行顺序，具体取决于操作系统的调度策略。 理解并熟练掌握...
关于多线程常用方法以及对锁的控制(详解)
08-30
多线程常用方法以及对锁的控制详解 多线程编程是Java编程中的一种重要技术，能够提高程序的执行效率和响应速度。但是，多线程编程也带来了许多挑战，如线程安全、锁的控制等。本文将详细介绍多线程常用方法以及对锁...
java线程池常用方法.docx
06-12
### Java线程池常用方法详解 #### 一、引言 自Java 5引入并发包`java.util.concurrent`以来，线程的管理与控制变得更为高效与便捷。在这个包中，`Executor`框架成为了线程管理和调度的核心。通过`Executor`，我们...
线程常用方法示例
02-06
.NET线程基本方法的使用Demo，包括Abort，Join，Sleep，Interrupt，Start等基本方法，使用小的Demo来入门应用线程
DemoUtil.zip_java常用工具方法
09-23
"DemoUtil.zip"这个压缩包中包含了一个名为"DemoUtil.java"的文件，这很可能是一个包含了各种Java常用工具方法的类。以下将详细介绍可能包含在这个类中的知识点。 1. **集合操作**：在Java开发中，集合框架（如...
详谈Java多线程的几个常用关键字
08-30
今天，我们就来详细讨论Java多线程中几个常用的关键字。 1. 同步（synchronized） 同步是一种锁机制，用于保护共享资源的访问。简单来说，同步可以理解为共享的意思，如果资源不是共享的，就没必要进行同步。设置...
线程常用方法你了解吗（join、yield、interrupt）
weixin_42118323的博客
03-30 1434
线程打断，打断调用者线程，但是 interrupt 方法和 stop 方法有本质区别，它并不会向 stop 方法一样直接中断一个线程的运行，调用 interrupt 方法的线程会继续运行下去，但是会设置一个中断标志 true，由调用者线程决定什么时候来来判执行线程中断，，，，，，，，，，，，，，，，，，。很明显使用 yield 方法，同样的逻辑处理，消耗的时间远大于使用了 yield 方法，证明 yield 方法生效，在实际的开发场景中，yield 方法的使用场景比较少。如有错误的地方欢迎指出纠正。
线程的常用方法汇总
zhangshenglu1的博客
03-07 310
如果在main线程中调用了t1.join(2000)，那么main线程会进入到等待状态，需要等待t1执行2s后，在恢复到就绪状态等待CPU调度。wait方法会将持有锁的线程从owner扔到WaitSet集合中，这个操作是在修改ObjectMonitor对象，如果没有持有synchronized锁的话，是无法操作ObjectMonitor对象的。如果在main线程中调用了t1.join()，那么main线程会进入到等待状态，需要等待t1线程全部执行完毕，在恢复到就绪状态等待CPU调度。
线程基本方法
weixin_43729205的博客
03-30 415
线程相关的基本方法有wait，notify，notifyAll，sleep，join，yield 等。 线程等待(wait) sleep 导致当前线程休眠，与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致 线程进入TIMED-WATING状态，而wait()方法会导致当前线程进入WATING状态 线程让步(yield) yield 会使当前线程让出 CPU...
线程的基本方法
u012632105的博客
03-06 1323
线程相关基本方法有wait、notify、notifyAll、sleep、yield、join等。这些方法控制线程之运行，并影响线程状态变化。
多线程之线程的常见方法
秉持长期主义，保持长期生命力和竞争力
03-01 114
常见方法
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
java 多线程常用方法
02-23
Java中多线程常用的方法有以下几种： 1. 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法，在run()方法中定义线程要执行的任务。然后通过创建子类的对象，调用start()方法启动线程。 2. 实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值