Java 多线程编程

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

一：线程的状态

二：线程常用方法

下面方法是被Thread对象调用的。

序号	方法描述
1	public void start() 使该线程开始执行；Java虚拟机调用该线程的run方法。
2	public void run() 如果线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回。
3	public final void setName(String name) 改变线程名称，使之与参数name相同。
4	public final void setPriority(int priority) 更改线程的优先级。
5	public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程
6	public final void join(long millisec) 等待该线程终止的时间最长为millis毫秒
7	public void interrupt() 中断线程。
8	public final boolean isAlive() 测试线程是否处于活动状态。

下面方法是被Thread类的静态方法。

序号	方法描述
1	public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
2	public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
3	public static boolean holdsLock(Object x) 当且仅当当前线程在指定的对象上保持监视器锁时，才返回true。
4	public static Thread currentThread() 返回对当前正在执行的线程对象的引用。
5	public static void dumpStack() 将当前线程的堆栈跟踪打印至标准错误流。

Executor 接口非常单一，就是执行一个Runnable命令

public interface Executor {
	void execute(Runnable command);
}

ExecutorService接口扩展了Executor接口，增加状态控制，执行多个任务返回Future。

public interface ExecutorService extends Executor {
	/*
		启动有序的关闭，在调用此方法之前向线程池提交的任务，继续执行，但不会接受新任务
		如果已经关闭，再调用此方法不会有其他影响
			
		此方法不会等待先前提交的任务完成后再执行，可以调用awaitTermination方法
		等待所有的任务执行完成。
	*/
	void shutdown();

	/*
		立刻关闭，尝试取消正在执行的任务（不会保证取消成功），返回未被执行的任务
	*/
	List<Runnable> shutdownNow();

	/*
		是否关闭
	*/
	boolean isShutdown();

	/*
		是否所有任务都执行完毕在shutdown之后，也就是如果不调用shutdownNow或者shutdown
		是不可能返回true
	*/
	boolean isTerminated();

	/*
		进行等待直到所有任务完成或者超时
	*/
	boolean awaitTermination(long timeout,TimeUnit unit)
			throws InterruptedException;
			
	/*
		提交一个可以返回的任务，并且返回一个有结果的Future
		Future的get方法可以获取任务执行完成后的结果
	*/
	<T> Future<T> submit(Callable<T> task);
	
	/*
		提交一个任务，并且返回一个有结果的Future
		Future的get方法可以获取任务执行完成后的结果
		注意：它是通过传入一个载体result间接获得线程的返回值
	*/
	<T> Future<T> submit(Runnable task, T result);

	/*
	提交一个可以运行的参数，Future的返回结果为null
	*/
	Future<?> submit(Runnable task);

	/*
		执行多个任务，等到所有任务执行完成才返回
	*/
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

	/*
		执行多个任务，超过等待时间，还未完成的任务会被取消
	*/
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
	
	/*
		执行多个任务，只要一个任务成功完成就返回这个任务的执行结果
	*/
	<T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

	/*
		执行多个任务，在等待时间内完成一个任务就会返回
	*/
	<T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

AbstractExecutorService对ExecutorService的执行任务类型的方法提供了一个默认实现。
（submit,invokeAny和invokeAll）

 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
 }
 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
 }
 public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
 } 
 public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
 }
 public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
 }

Future接口主要包括5个方法
对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、
获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

public interface Future<V> {
	/*
		这个方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），
		则返回true，如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false。
	*/
	boolean cancel(boolean mayInterruptIfRunning);
	/*
		判断当前方法是否取消
	*/
	boolean isCancelled();
	/*
		判断当前方法是否完成
	*/
	boolean isDone();
	/*
		当前任务结束后返回一个结果，如果调用，工作还没有结束，则会阻塞线程，
		直到任务执行完毕
	*/
	V get() throws InterruptedException,ExecutionExeption;
	/*
		和上面一样，不过是在给定的timeout的时间内完成计算，就会返回结果
	*/
	V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

	
}

Future:

1. 判断任务是否完成
2. 能够中断任务
3. 能够获取任务执行结果

RunnableFuture

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * 为此future设置计算过程，除非它已被取消
     */
    void run();
}

FutureTask是RunnableFuture的实现（事实上，FutureTask是Future接口的一个唯一实现类）
所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

这个任务的运行状态，初始为NEW。
运行状态只在set、setException、and cancel方法中转换终端状态。
在完成过程中、状态可能具有完成(while outcome is being set)
或中断（only while interrupting the runner to satisfy a cancel(true)）
的临时值。
从这些中间状态到最终状态的转换使用更方便的顺序/延迟写入,
因为值是唯一的，不能进一步修改
    private volatile int state; // 状态 
    private static final int NEW          = 0; // 新建
    private static final int COMPLETING   = 1; // 完成中
    private static final int NORMAL       = 2; // 完成
    private static final int EXCEPTIONAL  = 3; // 异常
    private static final int CANCELLED    = 4; // 取消
    private static final int INTERRUPTING = 5; // 中断中
    private static final int INTERRUPTED  = 6; // 中断

	/** 底层callable; 运行后为空 */
    private Callable<V> callable;
    /** 调用get返回的结果，或者引发异常 */
    private Object outcome; // 不是共享的，读写受状态的保护
    /** 用线程运行Callable；并用run()覆盖 */
    private volatile Thread runner;
    /** 等待线程的Treiber stack  */
    private volatile WaitNode waiters;

可能的状态转换

Future------------------------------>FutureTask

/*****************************Future实现**********************************/
	/*
		这个方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），
		则返回true，如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false。
	*/
    public boolean cancel(boolean mayInterruptIfRunning) {
        //判断任务是否完成
        if (!(state == NEW &&
        	  // 调用JNI方法（CAS算法---var1:给定的对象，
        	  // va2:对象内字段的偏移量，
        	  // var4:期望值,var5:要设置的值）
        	  // 让内存值和一个给定的值（var4）做比较，如果相等就会把内存值更新为另一个给定的值(var5)
              UNSAFE.compareAndSwapInt(thi                                                           s, stateOffset, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // 调用中断时防止引发异常
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                	// 有序写入
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }