Java(8-1)

不知道多久了，这次该说多线程了。
Part 1如何设置一个多线程：
①将任务代码移到实现了Runnable接口的类的run方法中。这个接口非常简单，只有一个方法：

public interface Runnable
{
    void run();
}
//这里由于Runnable是一个函数式接口，所以我们可以使用lambda表达式。
//当然，现在来说公司中用的更多地是匿名类来实现这个

②由Runnable创建一个Thread（英文就是线程的意思）对象:

Thread t = new Thread(t);

③启动线程:

t.start()

就这么简单！另外提一下，我们也可以通过构建一个Thread类的子类来定义一个线程,然后调用statr方法，例如：

class MyThread extends Thread
{
    public void run()
    {
        //code
    }
}

但是这种方法已经不推荐了！应该将要并行运行的任务和运行机制解耦合。如果有很多任务，要为每个任务创建一个独立的线程，那付出的代价太大了！还有一点，不要调用Thread的run方法，这样只会执行同一个线程中的人物，而不会启动新线程！
看一个银行系统的例子：

public class BankTest{
    public static final int NACCOUNTS = 100;
    public static final double INITIAL_BALANCE = 1000;
    public static final double MAX_AMOUNT = 1000;
    public static final int DELAY = 10;

    public static void main(String[] args)
    {
        Bank bank = new Bank(NACCOUNTS,INITIAL_BALANCE);
        for(int i = 0;i < NACCOUNTS;i++)
        {
            int fromAccount = i;
            Runnable r = new Runnable(){
                try{
                    while(true){
                        int toAccount = (int)(bank.size() * Math.random());
                        double amount = MAX_AMOUNT * Math.random();
                        bank.transfer(fromAccount,toAccount,amount);
                        Thread.sleep((int)(DELAY * Math.random()));
                    }
                }
                catch(InterruptedException e){}
            };
            Thread t = new Thread(r);
            t.start();
        }
    }
}

Part2 关于中断线程
我们先看下线程终止的条件：当线程的run方法执行方法体中最后一条语句时，并经由执行return语句返回时，或者出现了在方法中没有捕获的异常时，线程将终止！

在早期版本中，Java还有一个stop方法，线程可以调用它终止线程，但是现在已经弃用了！所以Java中目前没有可以强制线程终止的方法，然而，我们有interrupt方法，可以用来请求终止线程。

当对一个线程调用interrupt方法时，线程的中断状态状态将被置位。这是每一个线程都会有的一个boolea类型标志，每个线程都应该不断地去检查这个Boolean标志，以判断线程是否被中断。

我们要想清楚中断状态位是否被置位，首先调用静态的Thread.currentThread方法获取当前线程，然后调用isInterrupted方法：

while(!Thread.currentThread().isInterrupted() && more work to do)
{
    do more work
}

但是，如果线程已经被阻塞，就无法检测中断状态！这就是产生 InterruptedException异常的地方（划重点！！！） 当在一个被阻塞的线程（调用sleep或者wait）上调用interrupt方法时，阻塞调用将会被 Interrupted Exception异常中断。

不过，被异常中断的线程并不意味着这个线程应该被终止。中断一个线程可能只是引起CPU的注意。被中断的线程可以决定如何响应中断。某些线程很重要，所以可能在处理完异常后又继续执行，而不理会中断。但是，更普遍的是，线程将简单地将中断作为一个终止请求。这种线程的run方法具有如下形式：

Runnable r = new Runnable(){
    try{
    ...
        while(!Thread.currentThread().isInterrupted()&&more work to do){
            do more work
        }
    }
    catch(InterruptedException e){
    // thread was interrupted during sleep or wait
    }
    finally{
        cleanup,if required
    }
    //exiting the run method treminates the thread
};

当我们的代码每次工作迭代之后都调用sleep方法（或者其他的可中断方法），isInterrupted检测既没有必要也没有用处。
还有！
如果在中断状态被位时调用sleep方法，线程不会休眠。相反，线程会清除这一状态！并抛出InterruptException。因此，如果你的循环调用sleep，不会检测中断状态。相反，你要捕获InterruptException异常：

Runnable r = new RunnableI(){
    try{
    ...
        while(more work to do){
            do more work
            Thread.sleep(delay);
        }
    }
    catch(InterruptedException e){
    }finally{
        cleanup,if required
    }
};

Tip:注意下interrupted和isInterrupted的区别 。 P634中有提到。

《java核心技术》的作者认为，将InterruptedException异常被抑制在很低层次（就像上面那样），是不值得赞同地，作者认为有两种合理的选择：
1.在catch子句中调用Thread.currentThread().interrupt()来设置中断状态。于是，调用者可以对其进行检测:

    {
        ...
        try{sleep(delay);}
        catch(InterruptedException e){Thread.currentThread().interrupt();}
    }

2.更好的方法是用throws InterruptedException标记你的方法，不采用try语句块捕获异常。于是，调用者（或者，最终的run方法）可以捕获这一异常。

void mySubTask() throws InterruptedException
{
...
x.sleep(delay);
...
}