Java多线程:生命周期,实现与调度

2017-04-10  本文已影响0人  CieloSun

前面几篇文章为Java多线程做足了铺垫,这篇终于到了正题,一起学习一下Java多线程的基础知识。

1. Java线程生命周期

下图表述了Java线程的几个基本状态:

  1. 等待阻塞:运行线程中的wait()方法,使本地线程进入阻塞状态。

  2. 同步阻塞:线程获取sychronized同步锁失败,进入同步阻塞状态。

  3. 其他阻塞:调用线程的sleep()或join()发出I/O请求,线程进入阻塞状态。当sleep()超时,join()等待线程终止或超时,处理完I/O时,线程重新进入就绪状态。

2. Java线程实现方法

2.1. 继承Thread类,重写run()方法

最基本的线程方式,通过继承Thread类,重写run()方法即可运行子线程。缺点是Java类只能有一个父类,如果所要使用的类本身有其他需要继承的实体,就会比较麻烦。

class MyThread extends Thread {
    private volatile boolean isRunning = true;
    public boolean isRunning() {
        return isRunning;
    }
    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    @Override
    public void run() {
        System.out.println("进入到run方法中了");
        while (isRunning == true) {
        }
        System.out.println("线程执行完成了");//结束线程,进入dead态
    }
}
public class RunThread{
    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();//创建线程,进入new态
            thread.start();//start线程,进入runnable态,CPU开始调度后进入running态
            Thread.sleep(1000);//阻塞主线程,进入blocked态
            thread.setRunning(false);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.2. 实现Runnable接口,便于继承其他类

针对Thread类继承可能存在困难的问题,利用Java接口无限制的特性,利用接口来进行线程实现。在运行时,需要运行一个thread并把接入了Runnable的类以参数形式传给thread。

class MyClass implements Runnable {
    private volatile boolean isRunning = true;
    public boolean isRunning() {
        return isRunning;
    }
    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    @Override
    public void run() {
        System.out.println("进入到run方法中了");
        while (isRunning == true) {
        }
        System.out.println("线程执行完成了");
    }
}
public class RunThread{
    public static void main(String[] args) {
        try {
            MyClass myClass=new MyClass();
            Thread thread=new Thread(myClass);
            thread.start();
            Thread.sleep(1000);
            myClass.setRunning(false);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们需要知道的是,Thread类本身就已经接入了Runnable接口,如果我们给一个自定义的已经重写run的Thread类的子类A传入一个接入Runnable的类B作为参数,那么该子类A会运行类B的run()函数,原因为,Thread中的run()函数代码如下:

  @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

可见,如果target存在,即有Runnable类的子类作为参数传递,则不运行Thread提供的run()方法。

最基本的Thread和Runnable有一个共同的问题,即是run()函数没有返回值,导致线程间交互会比较复杂,需要依赖引用的互相传递。因此,当需要有返回值时,Java提供了另外的类。

2.3. Callable类替换Runnable类,实现返回值

Callable接口定义如下:

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

对于Callablel类我们只需要知道以下几点

  1. 需要实现重写其call()函数来实现功能。

  2. 泛型的输入类型即是call()的返回类型。

实现了call函数,简单的把Callable接口替换Runnable接口,我们就可以实现简答的有返回值线程了,但Java提供了更多的线程状态检查,控制类来更好的使用这两个接口。

2.4. Future接口对任务进行监测

Future接口有5个方法,我们依次来进行介绍

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2.5. FutureTask类:Future类的唯一实现

FutureTask类实现了RunnableFuture接口,而RunnableFuture接口如同名字一样,接入了Runnable和Future两个类。因此FutrueTask既可以作为Runnable被线程执行(自动调用其run()方法),同时又可以视为Future类来得到Callable类的返回值。此处我们可以看到Java设置这个类的用意——让用户尽量使用这个类去管理线程。

使用FutureTask类托管Callable的一个例子:

class MyClass implements Callable {
    private volatile boolean isRunning = true;
    public boolean isRunning() {
        return isRunning;
    }
    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    @Override
    public Object call() {
        System.out.println("进入到run方法中了");
        while (isRunning == true) {
        }
        System.out.println("线程执行完成了");
        return isRunning;
    }
}
public class RunThread{
    public static void main(String[] args) {
        try {
            MyClass myClass=new MyClass();
            FutureTask futureTask=new FutureTask(myClass);
            Thread thread=new Thread(futureTask);
            thread.start();
            Thread.sleep(1000);
            myClass.setRunning(false);
            try{
                System.out.println(futureTask.get());
            }
            catch (Exception e){
                System.out.println("Type error");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. Java多线程的调度

3.1. Java多线程的就绪,运行和死亡

如图,需要注意的是CPU调度线程有随机性,不排除线程调用yield()进入就绪状态后CPU又去调用线程的情况。

3.2. Java线程的阻塞

3.2.1. Java线程的阻塞方法

public static void main(String[] args){
  ......
  threadA.join();
}

3.3. 后台线程

后台线程主要为其他线程提供服务,或“守护线程”。例如:JVM的GC线程。后台线程与前台线程生命周期有一定关联。主要体现在:当所有前台线程死去时,后台线程也会自动死去。

设置一个线程是否为后台线程只需要调用该线程的setDaemon(boolean val)方法即可,创建一个线程后,默认为非后台线程。

public static void main(String[] args){
  ......
  threadA.setDaemon(true);
}

3.4. 线程的优先级

考虑到下面的情景,5个线程竞争同一资源,资源目前被重要线程A锁定,当线程A执行完毕,解锁释放资源后,我们希望重要线程E能先于BCD得到资源。此时,我们则需要优先级这个属性。每个线程都有一个优先级变量,该变量的值可以是1到10之间的一个常数。数字越大,代表优先级越高。Java给了其中三个常量名称,分别是:

MAX_PRIORITY:10

MIN_PRIORITY:1

NORM_PRIORITY:5

默认情况下,一个线程的优先级是其父线程的优先级。而主线程的优先级是NORM_PRIORITY,即数字5,因此,我们可以看到很多资料里认为现成的默认优先级是5,其实不是这样的。我们可以通过调用线程的setPrority(short val)来设置线程的优先级以及使用getPrority()来获取优先级。

class MyClass implements Callable {
    @Override
    public Object call() {
        System.out.println("线程执行完成了,将返回其子线程的优先级");
        return new Thread().getPriority();
    }
}

public class RunThread {
    public static void main(String[] args) {
        FutureTask futureTask = new FutureTask(new MyClass());
        Thread thread = new Thread(futureTask);
        thread.setPriority(3);
        System.out.println("设置该线程的优先级为"+thread.getPriority());
        thread.start();
        try {
            System.out.println("该线程的子线程优先级为" + futureTask.get());
        } catch (Exception e) {
            System.out.println("Type error");
        }
    }
}

上面这段代码的返回内容如下:

设置该线程的优先级为3
线程执行完成了,将返回其子线程的优先级
该线程的子线程优先级为3

然而,需要注意的是,优先级无法保证线程的执行顺序,即在BCDE竞争资源的情境中,无法保证E线程一定先执行。优先级高则其获取CPU资源的可能性比较大,而不是一定会先于其他线程获取执行优先权,优先级低的线程仍有得到执行权的可能。

同时我们不要忘记,Java的Thread类的核心方法是native方法,即是线程实现大量依赖宿主机的机制。Java有10个优先级,如果宿主机是Linux系统,有31个优先级,显然没什么问题。但如果宿主机是Windows7,只有7个优先级,那么Java的10个优先级就会根据系统的优先级进行映射。同时,线程的优先级也会受到虚拟机的影响。

3.5. 线程让步yield()

前面多少也提到过了。yield()和sleep()类似,是静态方法,作用于将当前运行的线程,其作用于具体线程,调用方法是Thread.yield(),使用t.yield()同样是能够使用但逻辑不清晰的做法。具体来说。yield()是让当前线程从running态回到runnable态。之后,线程间重新进行资源竞争,由CPU进行调度,因此yield()实际上是一个与锁不是很有关系的方法,和sleep()一样,作为当前线程的主动方法,不会引起死锁。

4. 参考文章

Java总结篇系列:Java多线程

Java并发编程:Callable,Future和FutureTask

线程的状态、分类及优先级

上一篇 下一篇

猜你喜欢

热点阅读