中断-阻塞

在其他对象上同步
synchronized块必须给定一个在其上进行同步的对象，并且最合理的方式是，使用其方法正在被调用的当前对象:synchronized(this)，这正是PairManager2所使用的方式。在这种方式中，如果获得了synchronized块上的锁，那么该对象其他的synchronized方法和临界区就不能被调用量。因此，如果在this上同步，临界区的效果就会直接缩小在同步的范围内。
有时必须在另一个对象上同步，但是如果你要这么做，就必须确保所有相关的任务都是在同一个对象上同步。

class DualSynch {
    private Object syncObject = new Object();

    public synchronized  void f() {
        for (int i = 0; i < 5; i++) {
            System.out.println("f()");
            Thread.yield();
        }
    }

    public  void g() {
        synchronized (syncObject) {
            for (int i = 0; i < 5; i++) {
                System.out.println("g()");
                Thread.yield();
            }
        }
    }
}

public class SyncObject {
    public static void main(String[] args) {
        final DualSynch dualSynch = new DualSynch();
        new Thread() {
            public void run() {
                dualSynch.f();
            }
        }.start();
        dualSynch.g();
    }
}

DaylSync.f（）(通过同步整个方法)在this同步，而g()有一个在syncObject上同步的synchronized块。因此，这两个同步是互相独立的。通过在main中创建调用f的Thread对这一点进行演示，因为main线程是被用来调用g的。从输出中可以看到，这两个方式在同时运行，因此任何一个方法都没有因为对另一个方法的同步而阻塞。
线程本地存储
防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同的线程都创建不同对的存储。因此，如果你有5个线程都要使用变量x所表示的对象，那线程本地存储就会生成5个用于x的不同的存储块。主要是，它们使得你可以将状态与线程关联起来。
创建和管理线程本地存储可以由java.long.ThreadLocal类来实现。

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class Accessor implements Runnable {

    private final int id;

    public Accessor(int idn) {
        id = idn;
    }

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) { // 是否中断
            ThreadLocalVariableHolder.increment();
            System.out.println(this);
            Thread.yield();
        }
    }

    @Override
    public String toString() {
        return "#" +id + ": "+ ThreadLocalVariableHolder.get();
    }
}


public class ThreadLocalVariableHolder {
    /**
     * // ThreadLocal对象通常当作静态域存储。
     * 在创建ThreadLocal时，你只能通过get和set方法访问该对象的内容，
     * 其中，get方法将返回与其线程相关联的对象的副本，而set会将参数插入到
     * 为其线程存储的对象中，并返回存储中原有的对象。
     * increment和get方法在ThreadLocalVariableHolder中演示了这一点。
     * 注意：increment和get方法都不是synchronized的，因为ThreadLocal保证了不会出现不限竞争条件。
     * 当运行这个程序时，你可以看到每个单独的线程都分配了自己的存储，因为它们每个都需要跟踪自己的计数值，
     * 即便只有一个ThreadLocalVariableHolder对象
     */
    private static ThreadLocal<Integer> value = new ThreadLocal<Integer>(){ 
        //线程变量，意思是ThreadLocal中填充的变量属于当前线程。
        // 该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。
        // ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
        private Random random = new Random();

        protected synchronized  Integer initialValue() {
            return random.nextInt(10000);
        }
    };

    public static void increment() {
        value.set(value.get()+1);
    }

    public static int get() {
        return value.get();
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            executorService.execute(new Accessor(i));
        }

        TimeUnit.SECONDS.sleep(3);

        executorService.shutdownNow(); //所有的Accessors 杀死
    }
}

终结任务
在前面的某些示例中，cancel和isCanceled方法被放到了一个所有任务都可以看到的类中。这些任务通过检查isCanceled来确定何时终止它们自己，对于这个问题来说，这是一种合理的方式。但是，在某些情况下，任务必须更加突然地终止。
装饰性花园
在这个仿真程序中，花园委员会希望了解每天通过多个大门进入公园的总人数。每个大门都有一个十字转门或某种其他形式的计数器，并且任何一个十字转门的计数值递增时，就表示公园中的总人数的共享计数值也会递增。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


class Count {
    private int count = 0;

    private Random rand = new Random(47);

    //删除synchronized关键字以查看计数失败
    // 如果移除synchronized ，就会有差异，只需要用互斥来同步对Count的访问。
    public synchronized int increment() {
        int temp = count;

        // 使用了Randon对象，目的是在从把count读取到temp中，到递增temp并将其存储到count的这段时间里，有大约一半的一半时间产生让步。
        // 如果synchronized关键字注释掉，那么这个程序就会崩溃，因为多个任务将同时访问并修改count

        if (rand.nextBoolean()) {
            Thread.yield();
        }

        return (count = ++temp);
    }

    public synchronized int value() {
        return count;
    }
}

/**
 * 单个Count对象来跟踪花园参观者的主计数值，并且将其Entrance类中的一个静态域进行存储。
 * Count.increment和Count.value都是synchronized的，用来控制对count域的访问。
 *
 * 每个Entrance任务都维护着一个本地值number，它包含通过某个特定入口进入的参观者的数量。
 * 这提供了对count对象的双重检查，以确保其记录的参观者数量是正确的。Entrance.run只是递增number和count对象，然后休眠100毫秒。
 *
 * 因为Entrance.canceled是一个volatile布尔标志，而它只会读取和赋值，所以不需要同步对其的访问，就可以安全地操作它，
 * 如果你对诸如此类的情况有任何疑虑，那么最好总是使用synchronized
 *
 */
class Entrance implements Runnable {

    private static Count count = new Count();

    private static List<Entrance> entries = new ArrayList<Entrance>();

    private int number = 0;

    //不需要同步来启动
    private final int id;

    private static volatile boolean canceled = false;

    public Entrance(int id) {
        this.id = id;
        //将此任务列在列表中.也可以防止死任务的垃圾收集
        entries.add(this);
    }

    public static void cancel() {
        canceled = true;
    }

    @Override
    public void run() {
        while (!canceled) {
            synchronized (this) {
                ++number;
            }
            System.out.println(this+" Total: " + count.increment());

            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("sleep interrupted");
            }
        }
        System.out.println("Stopping "+ this);
    }

    public synchronized int getValue() {
        return number;
    }

    public String toString() {
        return "Entrance " + id + ": " + getValue();
    }

    public static int getTotalCount() {
        return count.value();
    }

    public static int sumEntrances() {
        int sum = 0;
        for (Entrance entry : entries) {
            sum += entry.getValue();
        }
        return sum;
    }
}

public class OrnamentalGarden {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            executorService.execute(new Entrance(i));
        }
        //跑一会儿。然后停下来收集数据
        TimeUnit.SECONDS.sleep(3);
        Entrance.cancel();
        executorService.shutdown();
        if (!executorService.awaitTermination(250, TimeUnit.MILLISECONDS)) { //等待任务结束，如果所有的任务在超时时间达到之前全部结束，则返回true 否则返回false。
                //表示不是所有所有的任务都已经结束了。尽管这会导致每个任务都退出其run方法，并因此作为任务而终止。
                // 但是Entrance对象仍旧是有效的，因为在构造器中，每个Entrance对象都存储在称为entrances的静态List<Entrance>中
                // 因此，sumEntrances仍旧可以作用于这些有效的Entrance对象。
            System.out.println("Some tasks were not terminated!");
        }

        System.out.println("Total: " + Entrance.getTotalCount());
        System.out.println("Sum of Entances: " + Entrance.sumEntrances());

    }
}

在阻塞时终结
前面示例中的Entrance.run在其循环中包含对sleep的调用。我们知道，sleep最终将唤醒，而任务也将返回循环的开始部分，去检查canceled标志，从而决定是否跳出循环。但是sleep一种情况，它使任务从执行状态变为阻塞状态，而有时你必须终止被阻塞的任务。
线程状态：
1：新建：当线程被创建时，它只会短暂的处于这种状态。此时它已经分配了必须的系统资源，并执行了初始化。此刻线程已经有资格获得CPU时间了，之后调度器将这个线程转变为可运行状态或阻塞状态。
2：就绪：在这种状态下，只要调度器把时间片分配给线程，线程就可以运行。也就是说，在任意时刻，线程可以运行也可以不运行。只要调度器能分配时间片给线程，它就可以运行；这不同于死亡和阻塞状态。
3：阻塞：线程能够运行，但是有某个条件阻止它的运行。当线程处于阻塞状态时，调度器将忽略线程，不会分配给线程任何CPU时间。直到线程重新进入了就绪状态，它才有可能执行操作。
4：死亡：处于死亡或终止状态的线程将不再是可调度的，并且再也不会得到CPU时间，它的任务已结束，或不再是可运行的。任务死亡的通常方式是从run方法返回，但是任务的线程还可以被中断，你将要看到这一点。
进入阻塞状态：
一个任务进入阻塞状态，可能有如下原因：
1：通过调用sleep使任务进入休眠状态，在这种情况下，任务在指定的时间内不会运行。
2：你通过调用wait使线程挂起。直到线程得到了notify或notifyAll消息或者signal或signalAll消息，线程才会进入就绪状态，我们将在稍后的小姐中验证这一点。
3：任务在等待某个输入输出完成。
4：任务视图在某个对象上调用其同步控制方法，但是对象锁不可用，因为另一个任务以及获取了这个锁。
在较早的代码中，也可能会看到用suspend和resume来阻塞和唤醒线程，但是在现代java中这些方法被废止了(可能导致死锁)。stop方法也已经被废止了，因为它不释放线程获得的锁，并且如果线程处于不一致的状态，其他任务可以在这种状态下浏览并修改他们。
有时你希望能够终止处于阻塞状态的任务。如果对于处于阻塞状态的任务，你不能等待其到达代码中可以检查器状态值的某一点，因而决定让它主动地终止，那么你就必须强制这个任务跳出阻塞状态。
中断：
在Runnable.run方法的中间打断它，与等待该方法到达对cancel标志的测试等。当你打断被阻塞的任务时，可能需要清理资源。正因为这一点，在任务的run方法中间打断，更像是抛出的异常，因此在java线程中的这种类型的异常中断中用到了异常。为了在以这种方式终止任务时，返回众所周知的良好状态，你必须执行考虑代码的执行路径，并仔细编写catch子句以正确清除所有事物。
Thread类包含interrupt方法，因此你可以终止被阻塞的任务，这种方法将设置线程的中断状态。如果一个线程已经被阻塞，或者试图执行一个阻塞操作，那么设置这个线程的中断状态将抛出InterruptedException。当抛出该异常或者该任务调用Thread.interrupted时，中断将被复位。正如你将看到的，Thread.interrupted提供了离开run循环而不抛出异常的第二种方式。
为了调用interrupt，你必须持有Thread对象，你可能已经注意到了，新的concurrent类似乎在避免对Thread对象的直接操作，转而尽量通过Executor来执行所有操作，如果你在Executor上调用shutdowmNow，那么它将发送一个Interrupt调用给它启动的所有线程。这么做是有意义的，因为当你完成工程中的某个部分或者整个程序时，通常会希望同时关闭某个特定Executor的所有任务。然后，你有时也会希望只中断某个单一任务，如果使用Executor，那么通过调用submit而不是executor来启动任务，就可以持有该任务的上下文，submit将返回一个Future<?>，其中有一个未修饰的参数，因为你永远都不会在骑上调用get----持有这个Future的关键在于你可以在其上调用cancel，并因此可以使用它来中断某个特定任务。如果你将true传递给cancel，那么它就会拥有在该线程上调用interrupt以停止这个线程的权限。因此，cancel是一种中断由Executor启动的单个线程的方式。