程序员java进阶干货Java jvm、jmm

Java并发编程系列--并发基础

2017-11-29  本文已影响176人  起个名忒难

java从诞生之日起，就明智的选择了内置对多线程的支持。

几个概念
在开始写并发之前，先介绍几个简单的概念：

程序、进程、线程

进程之间不能共享内存，线程共享内存非常容易。

线程的状态
线程是有生命周期的，生命周期的状态如下：

Java程序中的线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换。转换图如下：


线程生命周期状态图.png

新建状态

就绪状态

运行状态

阻塞状态/等待/超时等待

线程结束

上面提到了线程创建的三种方式，在代码层级来看看线程的具体实现：

线程的创建

继承Thread类


public class ThreadTest extends  Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("我是线程执行体 ！");
    }
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

实现Runnable接口


class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println("runnable 执行体");
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        thread.start();
    }
}

实现Callable接口和FutureTask

class callableTest implements Callable{

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return 3;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        callableTest callableTest = new callableTest();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableTest);
        Thread thread = new Thread(futureTask , "有返回值的线程");
        thread.start();
        System.out.println(Thread.currentThread().getName());
        System.out.println(futureTask.get());
    }
}

上面展示了三种创建线程的三种方式，下面做一下简要的分析：

一般推荐使用实现接口的方式来创建多线程。

线程执行的任务定义在了run()方法中，只有通过start()方法才能创建线程，这是为什么呢，通过源代码来分析一下：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runable是一个函数式接口，定义也比较简单，只是定义了一个抽象的方法。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

Callable也是一个函数式接口，并且支持泛型，并返回泛型的类型。

看一下Thread类的实现，Thread类的代码比较多，这里只阐述一些重要的点：

先来看Thread类的定义

public class Thread implements Runnable

Thead类实现了Runable接口

构造方法： Thread类提供了9个构造方法，只阐述2个构造方法，这两个也是最常用的方法，如下。

public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

//init 方法重载
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }
private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {

        this.name = name.toCharArray();
        //删除了一些代码，这些代码会获取一些父线程的属性，并设置到当前线程
        ....  

        this.target = target;  //敲黑板，画重点
    }

上面的代码是一个线程的创建过程，包括获取一些父进程的属性，如设置线程的名字，设置是否是守护进程，优先级等。如果在创建线程的时候没有指定线程的名字，那么线程的名字为：Thread-num的形式，就是通过上面的代码来创建的，nextThreadNum()方法会返回一个数字，nextThreadNum()是一个被synchronized关键字修饰的方法，会将一个被static int类型修饰的整数进行+1操作,并返回，这样就保证了线程的名字不会重复，当然也可以自己指定线程的名字，在创建的时候传入即可。

上面代码target是一个私有的Runable变量，定义如下：

    private Runnable target;

看一下Thread类的start()方法：

public synchronized void start() {

        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();   //敲黑板，画重点，调用start0()方法
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
private native void start0();

start()方法是一个同步方法，并且会调用start0()来运行，start0()方法是一个被native修饰的本地方法，将委托给操作系统来运行，并调用run()方法。

定义如下：

private native void start0();

调用start()方法后，线程就处于了就绪状态，系统调度后，变为运行状态，并调用run()方法， 看一下run()方法的定义：

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

Thread类实现了Runbale接口所以必须要实现run()，run()方法的实现比较简单，首先判断target对象是否为null，如果为null就什么也不做，如果不为null,则调用target对象的run()方法。

分析到这，应该就能明白，有很多书上都说，无论是继承Thread类，还是实现了Runable接口都必须要重写run()方法，原因就在这。

继承Thread类的对象，调用Thread类的无参构造方法，此时target对象为空，但是它重写了run()方法，它会调用自己的run方法，实现了Runnable接口的对象，需要借助Thread(Runable target ) 构造方法运行 ， 此时target对象不为空，会调用target的run()方法。

关于Callable和FutureTask的实现方式，这里简单说一下， FutureTask实现了 RunnableFuture接口， 而RunnableFuture接口继承了Runable接口， 所以它能通过new Thread(Runnable target)构造函数来运行。会调用FutureTask的run()方法，在run()方法中调用了Callable对象的call()方法，获得了其返回值，换句话说 FutureTask对象封装了该Callable对象的返回值。通过FutureTask的get()方法来获得子线程执行结束后的返回值。

线程控制

上一篇 下一篇

猜你喜欢

热点阅读