Java多线程-线程状态以及常用方法

最新推荐文章于 2021-04-01 21:52:42 发布

XiangYida

最新推荐文章于 2021-04-01 21:52:42 发布

阅读量218

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/qq_36781505/article/details/88697118

版权

JavaSE 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1、线程状态转换

在这里插入图片描述

1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
- （一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
- （二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
- （三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

2、线程调度

1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
- Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
- static int MAX_PRIORITY 线程可以具有的最高优先级，取值为10。
- static int MIN_PRIORITY 线程可以具有的最低优先级，取值为1。
- static int NORM_PRIORITY 分配给线程的默认优先级，取值为5。
- Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。
JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操
作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用
了同样的调度方式。
2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的
时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的
notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，
行为等价于调用 wait(0) 一样。
4、线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更
高优先级的线程。
5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当
前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
6、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线
程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。
线程通过调用其中一个 wait 方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定
，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进
行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方
法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。
注意：Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向。

3、常用函数

1、`join()`

该方法的作用是，比如在A线程里面调用了B线程的join()方法，那么A线程进入阻塞状态，等待B线程
执行完毕
代码如下

package xyh;
import java.util.*;
import java.util.concurrent.ThreadPoolExecutor;
/**
 * @author XiangYida
 * @version 2019/3/4 19:36
 */
public class TestCollections {
    public class T1 extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("begin");
        TestCollections testCollections=new TestCollections();
        T1 t1=testCollections.new T1();
        T1 t2=testCollections.new T1();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("end");
    }
}

打印结果

begin
0
0
1
1
2
2
3
3
4
4
end
Process finished with exit code 0

为什么要用join()方法
- 在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将
  于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线
  程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

2、`yield()`

暂停当前正在执行的线程对象，并执行其他线程。
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行
机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证
yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

/**
 *@functon 多线程学习 yield
 *@author 林炳文
 *@time 2015.3.9
 */
package com.multithread.yield;
class ThreadYield extends Thread{
    public ThreadYield(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("" + this.getName() + "-----" + i);
            // 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
            if (i ==30) {
                this.yield();
            }
        }

}
}

public class Main {

    public static void main(String[] args) {

        ThreadYield yt1 = new ThreadYield("张三");
        ThreadYield yt2 = new ThreadYield("李四");
        yt1.start();
        yt2.start();
    }

}

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。

第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。

3、`setPriority()`

更改线程的优先级。

MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

4、`interrupt()`

不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时
（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！

5、`wait()`

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对
已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在
synchronized(Obj){…}语句块内。从功能上来说wait就是说线程在获取对象锁后，
主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，
并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是
马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()
对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的
操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于
Object.wait()在释放CPU同时，释放了对象锁的控制。

6、`synchronized`

同步与异步
同步和异步通常用来形容一次方法调用。
同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。
异步方法调用更像一个消息传递，一旦开始，方法调用就会立即返回，调用者就可以继续后续的操作。而，异步方法通常会在另外一个线程中，“真实”地执行着。整个过程，不会阻碍调用者的工作。

synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁
测试代码

public class Num {
    private int i=0;
    synchronized void set(int i1){
        System.out.println("i= "+i1);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" is end=======");
    }
}

public class Main {
    public static void main(String[] args) {
        //两个对象
        Num num1=new Num();
        Num num2=new Num();
        A a=new A(num1);
        B b=new B(num2);
      a.start();
      b.start();
    }
}
class A extends Thread{
    private Num num;
    public A(Num num){
        this.num=num;
    }
    @Override
    public void run() {
        num.set(1);
    }
}
class B extends Thread{
    private Num num;
    public B(Num num){
        this.num=num;
    }
    @Override
    public void run() {
        num.set(2);
    }
}

结果

i= 1
i= 2
Thread-1 is end=======
Thread-0 is end=======

两个对象的时候，加锁与不加锁一样。两个线程访问两个对象毫无影响
那么当一个对象的时候呢？

public class Main {
    public static void main(String[] args) {
        Num num1=new Num();
        A a=new A(num1);
        B b=new B(num1);
      a.start();
      b.start();
    }
}

结果

i= 1
Thread-0 is end=======
i= 2
Thread-1 is end=======

如果多个线程访问的是同一个对象，哪个线程先执行带synchronized关键字的方法，则哪个线
程就持有该方法，那么其他线程只能呈等待状态。如果多个线程访问的是多个对象则不一定，
因为多个对象会产生多个锁。

synchronized（object）代码块间使用

public class Num {
    private int i = 0;

    void set(int i1) {
        synchronized (this) {
            i += 1;
            System.out.println("i1= " + i1);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " i= " + i);
    }
}

结果

i1= 1
i1= 2
Thread-1 i= 2
Thread-0 i= 2

原因，synchronized仅仅锁住了构造i这块代码，当第一个线程让i+1，此时释放了锁进入休眠，然后线程2获得锁继续加一，然后i就等于2了

当一个对象访问synchronized(this)代码块时，其他线程对同一个对象中所有其他synchronized(this)代码块代码块的访问将被阻塞，这说明synchronized(this)代码块使用的“对象监视器”是一个。
也就是说和synchronized方法一样，synchronized(this)代码块也是锁定当前对象的。
另外通过上面的学习我们可以得出两个结论。
如果两个线程使用了同一个“对象监视器”,运行结果同步，否则不同步

参考资料:
https://www.cnblogs.com/wxd0108/p/5479442.html
https://www.cnblogs.com/yjd_hycf_space/p/7526608.html
https://blog.csdn.net/qq_34337272/article/details/79670775

XiangYida

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程-线程状态以及常用方法

1、线程状态转换1、新建状态（New）：新创建了一个线程对象。2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。...
复制链接

扫一扫