Java教程

java基础知识回顾之java Thread类学习(四)--线程的状态以及转化使用的方法介绍

本文主要是介绍java基础知识回顾之java Thread类学习(四)--线程的状态以及转化使用的方法介绍,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

java基础知识回顾之java Thread类学习(十)--线程的状态以及转化使用的方法介绍

 

   线程的概述:

        线程是程序的多个执行路径,执行调度的单位,依托于进程存在。线程不仅可以共享进程的内存,而且还拥有一个属于自己的内存空间,这段内存空间叫做线程栈,是建立线程的时候由系统分配的,主要用来保存线程内部的数据,如线程执行函数中定义的变量。

    java中多线程是一种抢占机制而不是分时机制。抢占机制是指CPU资源师被多个线程所共享,多个线程处于可运行状态,但是只允许一个线程在运行,他们通过竞争的方式抢占CPU.可以参考java 进程与线程的区别

 线程的状态:

  • 新生状态(New):当一个线程被创建一个线程实例后new Thread()或者new Thread(Runnable r),此线程处于新生状态,处于新生状态,线程有自己的内存空间,但该线程没有运行,此时该线程还不是活着的(not Alive)。
  • 就绪状态(Runnable):通过线程对象的start()方法启动线程使线程进入就绪状态(runnable),处于就绪状态的线程具备了运行条件(CPU执行资格),但是还没有抢到CPU执行权,不一定会被立即执行。此时线程在线程就绪队列中,等待系统为其分配CPU.等待状态不是执行状态,此时线程是活着的(isAlive=true).
  • 运行状态(Running):一旦线程抢到CPU执行权,线程进入运行状态(running),线程run方法才开始执行,运行状态的线程执行自己run方法里面的代码,直到调用其他方法而终止,或者等待某种资源而阻塞,或者完成任务而死亡;如果再给定的时间片内程序没有执行结束,就会被系统暂停当前正在运行的调度程序,回到线程的等待状态。此时线程是活着的(Alive)
  • 阻塞状态:(Blocked):通过调用join,sleep,wait或者资源被占用,使线程处于阻塞状态(blocked),处于阻塞状态的线程仍然活着。
  • 死亡状态:(Dead):当一个线程的run方法中的代码运行完毕,或被中断,或被异常退出,该线程处于死亡状态。一旦线程进入dead状态,它就再也不能进入一个独立线程的生命周期了,对一个处于dead状态的线程调用start方法,会出现runtime exception异常;处于dead状态的线程不是活着的(Alive)

 线程的方法和属性:

  • 优先级(priority):每一个线程都有一个优先级。默认优先级是5,优先级最高是10;优先级高的线程并不一定比优先级低的线程执行的机会高,只是执行的机率高;默认一个线程的优先级和创建他的线程优先级相同;setPriority(Thread.MAX_PRIORITY)方法来设置线程的优先级。
  • sleep(long millis)/sleep(long millis, int nanos)线程休眠:使当执行的线程休眠指定时间。作用:保持对象锁,让出CPU,调用目的是不让当前线程独自霸占该进程所获取的CPU资源,以留一定的时间给其他线程执行的机会;
  • Thread.yield():让出CPU的执行权,暂停当前执行的线程对象,让同等优先级的线程运行。稍微的释放执行权一会儿,时间不会很长。
  • Thread.join():用来临时加入线程执行,抢夺CPU执行权。例如:当A线程执行到B线程的Join方法时,A就会等待,等B线程执行完之后,A线程才会执行。
  •   object.wait():用在同步中,如果不在锁中使用会抛出IllegalMonitorStateException异常。使线程处于阻塞状态,是线程进入等待池中,释放锁,释放执行权

  • object.notify()/notifyAll():唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁,否则也会抛出IllegalMonitorStateException异常。
  •   Synchronizing Block:机锁具有独占性、一旦被一个Thread持有,其他的Thread就不能再拥有(不能访问其他同步方法),方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。

     

下面给出上面方法的测试代码:

   yield(),join(),priority属性的测试,其它方法不测试了,在是我的文章里面可以看到:

 设计两个线程,一个线程为主线程,一个线程Thread-0:

代码:没有用Join方法主线程和Thread-0交替的执行。大家都知道,这里不测试了。但是用了join方法大家看效果.

join方法的源码:      

复制代码
* Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     *
     * @param  millis
     *         the time to wait in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
       
     */
    // 加锁当前线程

    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            //A线程是start,在运行中
            while (isAlive()) {
          //main线程等待
                wait(0);
            }
        } else {
            //join(timeOut)的情况
            while (isAlive()) {
          //根据当前timeout的时间-now 是否<=0进行判断,主线程是否继续阻塞等待
                long delay = millis - now;
                //等待超时时间到了,则主线程不阻塞了,等待结束
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                //子线程从循环开始到现在运行的时间
                now = System.currentTimeMillis() - base;
            }
        }
    }
复制代码

给一个例子来理解:

复制代码
package concurrentMy.joins;

/**
 * 
 * @author Administrator
 * 
 * main 线程 和 A线程,A线程是main线程创建并且启动的,main线程优先级比较高,正在执行;
 * 这个时候main线程调用A.join()之后,main线程一直等待,直到A线程运行完毕,main线程才运行
 * 
 */
class ThreadA extends Thread {
    
    public ThreadA(String name){
        super(name);
    }

    @Override
    public void run() {
       、
        for (int i = 0; i < 20; i++) {
            // 复写父类的toString方法, 返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
            // Thread[Thread-1,5,main]默认的优先级为5,优先级从1-10
            System.out.println(Thread.currentThread().getName() + "-" + i);

        }
    }

}

public class JoinDemo {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        ThreadA A = new ThreadA("线程A");
        A.start();
        A.join(); //A线程加入到“main线程”中,main线程一直等待,直到A线程执行完毕,main线程才运行
        System.out.println(Thread.currentThread().getName() + "执行");
        System.out.println(Thread.currentThread().getName() + "执行终止");

    }

}
复制代码

 输出结果:

复制代码
线程A-0
线程A-1
线程A-2
线程A-3
线程A-4
线程A-5
线程A-6
线程A-7
线程A-8
线程A-9
线程A-10
线程A-11
线程A-12
线程A-13
线程A-14
线程A-15
线程A-16
线程A-17
线程A-18
线程A-19
main执行
main执行终止
  
复制代码

代码运行整个过程如下图:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

例子2,优先级测试

复制代码
package com.lp.ecjtu.Thread;
/**
 * 
 * @author Administrator
 * 当A线程执行到B线程的Join方法时,A就会等待,等B线程执行完之后,A线程才会执行
 * Join方法可以用来临时加入线程执行
 */
class Join implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            //复写父类的toString方法, 返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
            //Thread[Thread-1,5,main]默认的优先级为5,优先级从1-10
            System.out.println(Thread.currentThread().toString()+"-"+i);
            
        }
    }
    
}
public class JoinDemo {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        Join join = new Join();
        Thread t1 = new Thread(join);
        Thread t2 = new Thread(join);
        t2.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级的方法
        t1.start();
        t2.start();
       
    }

}
复制代码

 

输出结果:

Thread[Thread-1,10,main]-0
Thread[Thread-1,10,main]-1
Thread[Thread-1,10,main]-2
Thread[Thread-1,10,main]-3
Thread[Thread-1,10,main]-4
Thread[Thread-1,10,main]-5
Thread[Thread-1,10,main]-6
Thread[Thread-0,5,main]-0
Thread[Thread-1,10,main]-7
Thread[Thread-1,10,main]-8
Thread[Thread-0,5,main]-1
Thread[Thread-1,10,main]-9
Thread[Thread-1,10,main]-10
Thread[Thread-1,10,main]-11
Thread[Thread-1,10,main]-12
Thread[Thread-1,10,main]-13
Thread[Thread-1,10,main]-14
Thread[Thread-1,10,main]-15
Thread[Thread-1,10,main]-16
Thread[Thread-1,10,main]-17
Thread[Thread-1,10,main]-18
Thread[Thread-0,5,main]-2
Thread[Thread-1,10,main]-19
Thread[Thread-0,5,main]-3
Thread[Thread-0,5,main]-4
Thread[Thread-0,5,main]-5
Thread[Thread-0,5,main]-6
Thread[Thread-0,5,main]-7
Thread[Thread-0,5,main]-8
Thread[Thread-0,5,main]-9
Thread[Thread-0,5,main]-10
Thread[Thread-0,5,main]-11
Thread[Thread-0,5,main]-12
Thread[Thread-0,5,main]-13
Thread[Thread-0,5,main]-14
Thread[Thread-0,5,main]-15
Thread[Thread-0,5,main]-16
Thread[Thread-0,5,main]-17
Thread[Thread-0,5,main]-18
Thread[Thread-0,5,main]-19

总结:从结果可以看出Thread-1,10,main优先级为10的线程2先执行。

yield方法是正在执行的线程释放执行权,暂停执行一小会儿。这里不测了。。。。。。

 

这篇关于java基础知识回顾之java Thread类学习(四)--线程的状态以及转化使用的方法介绍的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!