章节21 并发

并发的多面性

用并发解决的问题可以分为速度和设计可管理性两种

更快的管理

如果有一台多处理器，就可以在这些处理器中分配任务，但是并发通常时提高在运行在单处理器上的程序的性能
并且单位时间内只有一个线程执行
如果程序中的某个任务应为该程序控制范围之外的某些条件而导致不能够继续运行，就说这个线程阻塞了

改进代码设计

Java的线程机制是抢占式的，这表示调度机制会在周期性的中断线程，切换到另外一个线程，从而为每个线程都提供时间片，使得每个线程都会分配到数量合理的时间去驱动它的任务

基本的线程机制

并发编程使我们可以将程序分为多个分离的，独立运行的任务。一个线程就是在进程中的一个单一的顺序控制流，因此进程可以拥有多个并发执行的任务

定义任务

描述任务，只需要实现Runnable接口即可

public class ListOff implements Runnable {
     //描述接口只需要实现这个接口
    private int countDown = 10;
    private static int taskCount = 0;
    private final int id = taskCount++;
    public ListOff(){}
    public ListOff(int countDown) {
        this.countDown = countDown;
    }
    public String status(){
        return "#" + id + "(" + (countDown > 0 ? countDown : "ListOff! ") + ")";
    }
    @Override
    public void run() {
        while (countDown-- > 0) {
            System.out.println(status());
            Thread.yield();
            //“让一下”，可以让别的线程抢占，但是抢到抢不到另说
        }
    }
}

可以在main方法中直接调用run方法

public class MainThread {
    public static void main(String[] args) {
        final ListOff listOff = new ListOff();
        listOff.run();//直接调用该方法
    }
}

每个实现了Runnable的类都会有run方法

Thread类

public class BasicThread {
    public static void main(String[] args) {
        final Thread thread = new Thread(new ListOff());
        thread.start();//执行线程必须的初始化
        System.out.println("waiting for ListOff");
        //从输出中看，虽然开始线程的运行，但是先打印出来的使main方法中的输出语句
    }
}

可以添加更多的线程去驱动更多的任务

public class MoreBasicThreads {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(new LiftOff()).start();//每一个线程都拥有一个LiftOff实例，所以不会发生资源竞争的问题
                                                //所以不会产生多资源问题
        }
        System.out.println("等待发射......");
    }
}

    public static void main(String[] args) {
        final Thread thread = new Thread(new LiftOff());
        for (int i = 0; i < 5; i++) {//一个线程五个资源：IllegalThreadStateException
            thread.start();
        }
        System.out.println("等待发射......");
    }
}

输出说明不同任务的执行在线程被换进换出时混在了一起，线程调度器会在这些处理器之间默默的分发线程

使用Executor

Executor在客户端和任务执行之间提供了一个间接层，与客户端直接执行任务不同，这个中介将执行任务。Executor允许管理异步任务的执行，而无需显示的管理线程的声明周期
ExecutorService：（具有服务声明周期的Executor）知道如何构建恰当的上下文来执行Runnable。
CachedThreadPool：为每一个任务都创建一个线程（创建与所需数量相同的线程）
ExecutorService对象是使用静态的Executor方法创建的

public class CachedThreadPool {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();//底层是用Thread实现
        //为每个任务都创建一个线程，并且如果以前创建的线程可用，会重用他们
        for (int i = 0; i < 5; i++) {
            exec.execute(new LiftOff());
        }
        exec.shutdown();//先执行Shutdown，如果有未完成的任务，会把任务完成，之后不允许再次提交任务
                        //如果在ShutDown之后再提交，会报错
    }
}

FixedThreadPool使用了有限的线程集来执行所提交的任务

public class FixedThreadPool {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(5);
                                //一次分配五个线程（可以分配任意个线程）
        for (int i = 0; i < 5; i++) {
            exec.execute(new LiftOff());//在线程中执行任务
        }
        exec.shutdown();
    }
}

在任何线程池中，如果已经创建的线程可用，都可以自动复用
SingleThreadExecutor：只有一个线程，就像是数量为1的FixedThreadPool，用这种方式，并不需要在共享资源上处理同步
线程池内部实现方式：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

从任务中产生返回值

Runnable是执行工作的独立任务，他没有任何返回值，如果希望在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable。
Callable是一个具有类型参数的泛型，它的类型参数是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它。

public Thread(Runnable target) {//Callable不能再线程中提交任务
        init(null, target, "Thread-" + nextThreadNum(), 0);

class TaskWithResult implements Callable<String> {
    private int id;
    public TaskWithResult(int id) {
        this.id = id;
    }
    @Override
    public String call() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "result of TaskWithResult " + id;
    }
}
public class CallableDemo {
    public static void main(String[] args) {
        System.out.println("------------");
        ExecutorService exec = Executors.newCachedThreadPool();
        ArrayList<Future<String>> result = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            result.add(exec.submit(new TaskWithResult(i)));
        }
        for (Future<String> fs : result) {
            try {
                System.out.println("0000000000000");
                System.out.println(fs.get());//调用get方法获取结果
                //System.out.println("1111111111111");
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }finally {
                exec.shutdown();
            }
        }
        System.out.println("==============");
    }
}

class TaskResult implements Callable<String> {
    private final int id;
    private static final Random rand = new Random(47);
    public TaskResult(int id){
        this.id = id;
    }
    @Override
    public String call() throws Exception {
        int timeout = rand.nextInt(10);
        TimeUnit.SECONDS.sleep(timeout);//随机睡眠时间
        return "当前线程名字 ： " + Thread.currentThread().getName() + " " +
                "执行了： " + timeout + "  id : " + id;
    }
}
public class CallableDemo {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        ArrayList<Future<String>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            futures.add(exec.submit(new TaskResult(i)));
        }
        long start = System.currentTimeMillis();
        for (Future<String> future : futures) {
            try {
                System.out.println(future.get());//只要线程完成了就会立即获取
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println(System.currentTimeMillis() - start / 1000);
        exec.shutdown();
    }
}

class TaskResult2 implements Callable<String> {
    private final int i;
    TaskResult2(int i) {
        this.i = i;
    }
    @Override
    public String call() throws Exception {
        TimeUnit.SECONDS.sleep(5);//模拟任务耗时的时间
        return "当前线程名字：" + Thread.currentThread().getName() + "  " + i;
    }
}
public class CallableDemo2 {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        Future<String> future = exec.submit(new TaskResult2(1));
        try {
            System.out.println("11111111111111111111");
            //System.out.println(future.get());//等待结果的获取 阻塞程序的执行
            System.out.println(future.get(1, TimeUnit.SECONDS));//只等待1秒钟获取结果
            System.out.println("22222222222222222222");
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            e.printStackTrace();
        }
        exec.shutdown(); //并不会阻塞当前程序的执行；如果任务没有执行完成的话，将等待任务执行完成之后再关闭
        System.out.println("这是main方法的程序......");
    }
}

class TaskResult3 implements Callable<String> {
    private final int i;
    TaskResult3(int i) {
        this.i = i;
    }
    @Override
    public String call() throws Exception {
        System.out.println("--------before sleep---------");
        TimeUnit.SECONDS.sleep(i);//模拟任务耗时的时间
        System.out.println("--------after sleep---------");
        return "当前线程名字：" + Thread.currentThread().getName() + "  " + i;
    }
}
public class CallableDemo3 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newSingleThreadExecutor();
        Future<String> future = exec.submit(new TaskResult3(3));
        try {
            System.out.println("---------1---------");
            System.out.println(future.get());
            System.out.println("---------2---------");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        exec.shutdown();
        System.out.println("其他程序继续执行");
    }
}

休眠

影响任务行为的一种简单的方法是调用sleep（）；这将是任务终止执行给定的时间

public class SleepingTask extends LiftOff {
    public void run() {
        try {
            while (countDown-- > 0) {
                System.out.print(status());
                TimeUnit.SECONDS.sleep(2);
            }
        } catch (InterruptedException e) {
            System.err.println("Interrupted");
        }
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++)
            exec.execute(new SleepingTask());
        exec.shutdown();
    }
}

优先级

调度器倾向于让优先权最高的线程先执行，但是，这并不是意味着优先权低的得不到执行，（优先权并不会导致死锁）可以使用getpriority（）来读取现有线程的优先权，并且任何时刻都可以通过setPriority（）来修改它

public class SimplePriorities implements Runnable {
    private int countDown = 5;
    private volatile double d; // No optimization
    private int priority;
    public SimplePriorities(int priority) {
        this.priority = priority;
    }
    public String toString() {
        return Thread.currentThread() + ": " + countDown;
    }
    public void run() {
        Thread.currentThread().setPriority(priority);
        //驱动对该任务的引用
        while (true) {
            for (int i = 1; i < 100000; i++) {
                d += (Math.PI + Math.E) / (double) i;
                if (i % 1000 == 0)
                    Thread.yield();
            }
            System.out.println(this);
            if (--countDown == 0) return;
        }
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++)
            exec.execute(
                    new SimplePriorities(Thread.MIN_PRIORITY));
        exec.execute(
                new SimplePriorities(Thread.MAX_PRIORITY));
        exec.shutdown();
    }
}

并不是优先级高的就会先输出

让步

yield（）：干一会，停一下，然后让别的线程可以抢一下，并不是说一定能够抢占成功

后台线程

后台线程指在程序运行时再后台提供的一种服务的线程。当所有的非后台线程结束的时候，程序也就终止了，并且会杀死程序中所有的后台线程，所以说只要还有非后台线程还在运行，程序就不会终止

public class SimpleDaemons implements Runnable {
    @Override
    public void run() {
        try {
            while (true) {
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(Thread.currentThread() + "  " + this);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("sleep() interrupted");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread daemon = new Thread(new SimpleDaemons());
            daemon.setDaemon(true);//将其设置成为后台线程
            daemon.start();
        }
        System.out.println("All daemons started");
        TimeUnit.MILLISECONDS.sleep(150);//如果它的休眠时间和它执行的休眠时间差不多的话，可能它执行不完
    }
}

必须要在线程启动之前将其设置为后台线程
上面的代码创建了显式的线程，可以设置他们的后台标志。
通过编写ThreadFactory可以定制由Executor创建的线程的属性（后台，优先级，名称）

public class DaemonFromFactory implements Runnable {
    @Override
    public void run() {
        try {
            while (true) {
                TimeUnit.MILLISECONDS.sleep(100);
                System.out.println(Thread.currentThread() + " " + this);
                TimeUnit.MILLISECONDS.sleep(200);
                System.out.println("是否执行了一半"); //第二此任务只会执行一半
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool(new DaemonThreadFactory());
        //使用线程池来创建后台线程
        for (int i = 0; i < 10; i++) {
            exec.execute(new DaemonFromFactory());
        }
        System.out.println("All Daemon started");
        TimeUnit.MILLISECONDS.sleep(500);
    }
}

可以通过isDaemon（）方法来确定线程是否是一个后台线程。如果是一个后台线程，那么它创建的任何线程都将被自动的设置成后台线程

class Daemon implements Runnable{
    Thread[] t = new Thread[10];
    @Override
    public void run() {
        for (int i = 0; i < t.length; i++) {
            t[i] = new Thread(new DaemonSpawn());
            //DaemonSpawn并没有显式的说明他是后台线程，但是已经将Daemon设置成为了后台线程
            //所以DaemonSpawn也被设置成为了后台线程
            t[i].start();
            System.out.println("Daemon " + i + " started");
        }
        for (int i = 0; i < t.length; i++) {
            System.out.println("t[+" + i + "].isDaemon()=" + t[i].isDaemon() + ",");
        }
        while (true) {
            Thread.yield();
        }
    }
}
class DaemonSpawn implements Runnable{
    @Override
    public void run() {
        while (true) {
            Thread.yield();
        }
    }
}
public class Daemons {
    public static void main(String[] args) throws InterruptedException {
        Thread d = new Thread(new Daemon());
        d.setDaemon(true);//将Daemon设置成为后台线程
        d.start();
        System.out.println("d.isDaemon() = " + d.isDaemon() + " ");
        TimeUnit.SECONDS.sleep(1);
    }
}

后台线程在不执行finally子句的情况下就会终止其run（）方法

class ADaemon implements Runnable{
    @Override
    public void run() {
        try {
            System.out.println("Starting ADaemon");
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            System.out.println("Exiting via InterruptedException");
        }finally {
            System.out.println("This should always run? ");
            //并没有执行finally子句，线程就结束了
        }
    }
}
public class DaemonsDontRunFinally {
    public static void main(String[] args) {
        Thread t = new Thread(new ADaemon());
        t.setDaemon(true);
        t.start();
    }
}

当最后一个非后台线程终止时，后台线程会突然终止，一次，一旦main方法退出，所有的后台线程都将会关闭

编码的变体

在非常简单的情况下，可以直接从Thread继承这种可替换的方式

public class SimpleThread extends Thread {
    private int countDown = 5;
    private static int threadCount = 0;
    public SimpleThread(){
        super(Integer.toString(++threadCount));//分配一个新的Thread对象
        start();
    }
    @Override
    public String toString() {
        return "#" + getName() + "(" + countDown + ")";
    }
    public void run(){
        while (true) {
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SimpleThread();
        }
    }
}

另一种实现Runnable方法

public class SelfManaged implements Runnable {
    private int countDown = 5;
    private Thread t = new Thread(this);//分配一个新的Thread对象
    public SelfManaged(){
        t.start();
    }
    @Override
    public String toString() {
        return Thread.currentThread().getName() + "(" + countDown + ")";
    }
    @Override
    public void run() {
        while (true) {
            System.out.println(this);
            if (countDown-- == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SelfManaged();
        }
    }
}

两者还是由区别的，实现Runnable接口可以继承另外的类，但是继承了Thread就不能在继承别的类，因为Java不允许多继承

术语

对Thread类实际没有任何控制权，实际操作是：创建任务，通过某种方式将一个线程附着在任务上，使得这个线程可以驱动任务，Thread类自身不执行任何操作，它只是驱动赋予它的任务（任务：比如Runnable接口中的run方法中的业务逻辑）

加入一个线程

一个线程可以在其他线程之上调用join方法，他会等待一段时间，直到这个线程结束（插队，谁调用join方法谁先执行），对join的调用可以被中断，在调用的线程上调用interrupt（）方法，这时需要try-catch子句

被加入的线程一定会被挂起？

class Sleeper extends Thread {
    private int duration;
    public Sleeper(String name, int sleepTime) {
        super(name);
        duration = sleepTime;
        start();//在构造器中间直接开始执行线程
    }
    public void run(){
        try {
            sleep(duration);
        } catch (InterruptedException e) {
            //被打断的信息在try catch之后它的被打断的信息就会被清除，所以isInterrupted在catch之后会返回到false
            System.out.println(getName() + " was interrupted  " + "isInterrupted(): " + isInterrupted());
            return;
        }
        System.out.println(getName() + "has awakened");//被打断，所以这一行不会执行
    }
}
class Joiner extends Thread {
    private Sleeper sleeper;
    public Joiner(String name, Sleeper sleeper) {
        super(name);
        this.sleeper = sleeper;
        start();//在构造器中直接开始线程
    }
    public void run(){
        try {
            sleeper.join();//插队，先执行，sleeper执行之后才会执行joiner
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
        System.out.println(getName() + " join completed");
    }
}
public class Joining {
    public static void main(String[] args) {
        //Sleeper sleepy = new Sleeper("Sleepy", 1500);
        Sleeper grumpy = new Sleeper("Grumpy", 1500);
        //Joiner dopey = new Joiner("Dopey", sleepy);
        Joiner doc = new Joiner("Doc", grumpy);
        grumpy.interrupt();
    }
}

package stu;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
class Aoo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("Aoo 线程 持有时间片");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Boo implements Runnable {
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Boo 线程 获得时间片");
    }
}
public class SleepJoin {
    public static void main(String[] args) throws InterruptedException {
        final Thread aoo = new Thread(new Aoo());
        System.out.println("Aoo 线程启动");
        aoo.start();
        for (int i = 0; i < 10; i++) {
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println("主线程");
        }
        aoo.join();
        for (int i = 0; i < 10; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println("主线程 持有时间片");
        }
    }
}

joiner任务耗时的话，会继续执行，和sleeper执行完成或者中断没有任何关系

捕获异常

由于线程的本质特性，所以不能捕获从线程逃逸的异常，除非使用特殊的步骤捕获这种错误的异常

public class ExceptionThread implements Runnable{
    @Override
    public void run() {
        throw new RuntimeException();//异常从线程中逃逸，没有被捕获，会打印错误信息
    }
    public static void main(String[] args) {
        //即使将try-catch将其包裹也没有用
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new ExceptionThread());
    }
}

Thread.UncaughtExceptionHandler允许你在每个Thread对象上都附着一个异常处理器
Thread.UncaughtExceptionHandler.uncaughtException()会在线程因未捕获的异常而临近死亡时调用它

class ExceptionThread2 implements Runnable {
    @Override
    public void run() {
        Thread t = Thread.currentThread();//当前的线程
        System.out.println("run() by " + t);
        System.out.println("eh = " + t.getUncaughtExceptionHandler());
        throw new RuntimeException();
    }
}
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("caught " + e);
    }
}
class HandlerThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        //System.out.println(this + " creating new Thread");
        Thread t = new Thread(r);//创建线程
        //System.out.println("created " + t);
        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());//设置线程处理器
        //System.out.println("eh = " + t.getUncaughtExceptionHandler());
        return t;
    }
}
public class CaptureUncaughtException {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());//执行任务
    }
}

共享资源受限

多个线程同时访问一个资源

不正确的访问资源

public abstract class IntGenerator {
    private volatile boolean canceled = false;
    public abstract int next();
    public void cancel(){
        canceled = true;
    }
    public boolean isCanceled(){
        return canceled;
    }
}

canceled的标志的boolean类型的，它是原子性的赋值和返回值这样的操作在发生时没有中断的可能，因此时看不到这些简单操作时的中间状态

public class EvenChecker implements  Runnable{
    private IntGenerator generator;
    private final int id;
    public EvenChecker(IntGenerator g, int ident) {
        generator = g;
        id = ident;
    }
    @Override
    public void run() {
        while (!generator.isCanceled()) {
            int val = generator.next();
            if (val % 2 != 0) {
                System.out.println(val + "not even");
                generator.cancel();
            }
        }
    }
    public static void test(IntGenerator gp, int count) {
        System.out.println("Press Control-C to exit");
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < count; i++) {
            exec.execute(new EvenChecker(gp,i));
        }
        exec.shutdown();
    }
    public static void test(IntGenerator gp) { //重载test方法，这时候只有一个IntGenerator类型的gp
                                                //所以他们访问的资源时同一个
        test(gp, 10);
    }
}

test重载之后，十个线程访问的是同一个gp，并且上述代码通过使代码依赖于非任务对象，可以消除潜在的竞争条件（）

public class EvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;
    @Override
    public int next() {
        ++currentEvenValue;//此处的操作每次都分三步走的，所以多线程访问的时候并不安全
        ++currentEvenValue;
        return currentEvenValue;
    }
    public static void main(String[] args) {
        EvenChecker.test(new EvenGenerator());
    }
}

在Java中，递增不属于原子操作，所以这种递增使不安全的

解决共享资源竞争

防止多个线程在访问同一个资源出问题的方法：当这个资源被某一个任务使用时，就给他加上锁，第一个访问某项资源的任务必须锁定这项资源，在被解锁之前，其他的任务不能访问这项资源
基本上所有的并发在解决线程冲突的时候都是采用顺序访问的方式，一段时间只有一个任务可以运行这段代码
Java提供了关键字synchronized，当任务执行被他保护的代码时，它会检查锁是否可用，然后来获取锁，执行代码，然后释放锁
如果某个任务正在执行被标记为synchronized的方法时，如果他没有冲该方法返回，那么在这个线程从该方法返回之前，其他要调用这个方法的线程都会被阻塞

public class InstanceSynchronized {
    public synchronized void f(){
        try {
            System.out.println("进入到f()方法");
            TimeUnit.SECONDS.sleep(3);
            System.out.println("f()方法执行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void g(){
        try {
            System.out.println("进入到g()方法");
            TimeUnit.SECONDS.sleep(5);
            System.out.println("g()方法执行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        final InstanceSynchronized in = new InstanceSynchronized();
        new Thread(in::f).start();
        //使用实例来调用两个方法，现在称synchornized为实例锁
        new Thread(in::g).start();
        f方法执行结束，释放了锁之后，这个实例才能调用被标记为synchornized的g方法
    }
}

在实例调用任意的synchronized方法的时候，这个实例都会被加上锁，这是这个实例上的其他synchronized方法只有等前一个调用完毕了之后释放了锁之后才能够被调用

注意，在使用并发时，将域设置成为private是十分重要的，否则，synchronized关键字就不能防止其他的任务直接访问域，这样会产生冲突

public class SynchronizedWithPrivateDemo {
    int num = 0;
    synchronized int getNum() {
        num++;
        num++;
        return num;
    }
}
class Demo {
    public static void main(String[] args) {
        SynchronizedWithPrivateDemo demo = new SynchronizedWithPrivateDemo();
        new Thread(() -> {
            int res = demo.getNum();
           /* try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(Thread.currentThread().getName() + "->" + res);
        }, "get-1").start();
        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            demo.num = 9999; //可以随意的将num的值更改，这并不是线程安全的
        }, "update-1").start();
        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int res = demo.getNum();
            System.out.println(Thread.currentThread().getName() + "->" + res);
        }, "get-2").start();
    }
}

如果正在写一个变量，它可能接下来被另一个线程读取，或者正在读取一个上一次已经被另一个线程写过的变量，那么必须使用同步，并且，读写线程都必须用相同的监视器锁同步（final修饰的线程一定是线程安全的）

同步控制EvenGenerator

public class SynchronizedEvenGenerator extends IntGenerator{
    private int currentEvenValue = 0;
    @Override
    public synchronized int next() { //上锁，其他的线程就进不来了
        ++currentEvenValue;
        Thread.yield();//已经上锁了，其他的线程抢不到
        ++currentEvenValue;
        return currentEvenValue;
    }
    public static void main(String[] args) {
        EvenChecker.test(new SynchronizedEvenGenerator());
    }
}

使用显示的Lock对象

Lock对象和Synchronized相比，必须显示的创建Lock对象，显示的锁定和释放

public class MutexEvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;
    private Lock lock = new ReentrantLock();//创建锁
       ReentrantLock，不公平锁，可重入锁
    @Override
    public int next() {
        lock.lock();//锁住
        try {
            ++currentEvenValue;
            Thread.yield();
            ++currentEvenValue;
            return currentEvenValue;//先执行finally，在执行return
        } finally {
            lock.unlock();//释放锁
        }
    }
    public static void main(String[] args) {
        EvenChecker.test(new MutexEvenGenerator());
    }
}

有了显示的Lock对象，就可以使用finally子句将系统维护在正确的状态
注意：return必须放在try语句中，为了防止unlock过早的发生，从而导致第二个任务进来

synchronized和Lock对象的区别：使用synchronized关键字的时候。需要写的代码量更少，并且用户出现错误的可能性更低，但是synchronized关键字不能尝试着获取锁且最终获取锁会失败，或者尝试着获取锁一段时间然后放弃它

public class AttemptLocking {
    private ReentrantLock lock = new ReentrantLock();
    public void untimed() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        boolean captured = lock.tryLock();
        try {
            System.out.println("tryLock()" + captured);
        }finally {
            if (captured) {
                lock.unlock();
            }
        }
    }
    public void timed() {
        boolean captured = false;
        try {
            System.out.println("tryLock(2,Times.SECONDS): " + captured);
        }finally {
            if (captured) {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final AttemptLocking al = new AttemptLocking();
        al.untimed();
        al.timed();
        new Thread(){   //可以将ReentrantLock看成是一个对象锁，谁先获得，将阻塞其他线程对该对象锁的获取
            {setDaemon(true);}
            public void run(){
                al.lock.lock();
                System.out.println("acquired");
            }
        }.start();
        Thread.yield();
        al.untimed();
        al.timed();
    }
}

ReentrantLock允许尝试获取锁，如果没有获取锁的话，可以离开去做一些其他的事情，而不是一直等待这个锁被释放

原子性与易变性

没有中间操作的操作，比如boolean，Atomicxxx的类都是原子类，这些代码不需要被同步
volitile关键字确保了应用中的可视性，如果将一个域声明为volatile的，那么只要对这个域进行了写操作，所有的读操作都会看到这个修改，修改volatile之后会被立即写入主存中，volatile一般配合着原子操作一起工作

public class AtomicityTest implements Runnable {
    private int i = 0;
    public int getValue(){
        return i;
    }
    private synchronized void evenIncrement(){
        i++;//这种操作都属于分布操作，所以可能会被读取到中间值
        //必须将getValue也给他设置成为synchronized的
        i++;
    }
    @Override
    public void run() {
        while (true) {
            evenIncrement();
        }
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        AtomicityTest at = new AtomicityTest();
        exec.execute(at);
        while (true) {
            int val = at.getValue();
            if (val % 2 != 0) {
                System.out.println(val);
                System.exit(0);
            }
        }
    }
}

public class SerialNumberGenerator {//产生序列数字的类
    private static volatile int serialNumber = 0;
    public static int nextSerialNumber() {
        return serialNumber++;
    }
}

如果一个域可能会被多个任务同时访问，或者这些任务中至少有一个是写入任务，那么就应该将这个域设置成为volatile的

class CircularSet {
    private int[] array;
    private int len;
    private int index = 0;
    public CircularSet(int size) {
        array = new int[size];
        len = size;
        for (int i = 0; i < size; i++)
            array[i] = -1;
    }
    public synchronized void add(int i) {
        array[index] = i;
        index = ++index % len;
    }
    public synchronized boolean contains(int val) {
        for (int i = 0; i < len; i++)
            if (array[i] == val) return true;
        return false;
    }
}
public class SerialNumberChecker {
    private static final int SIZE = 10;
    private static CircularSet serials =
            new CircularSet(1000);
    private static ExecutorService exec =
            Executors.newCachedThreadPool();
    static class SerialChecker implements Runnable {
        public void run() {
            while (true) {
                int serial =
                        SerialNumberGenerator.nextSerialNumber();//产生多线程问题的源头
                if (serials.contains(serial)) {
                    System.out.println("Duplicate: " + serial);
                    System.exit(0);
                }
                serials.add(serial);
            }
        }
    }
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < SIZE; i++)
            exec.execute(new SerialChecker());
        if (args.length > 0) {
            TimeUnit.SECONDS.sleep(new Integer(args[0]));
            System.out.println("No duplicates detected");
            System.exit(0);
        }
    }
}

CircularSet：持有所产生的所有序列数，另外还包括一个内嵌的SerialChecker类，它可以保证序列数是唯一的，创建多个任务来竞争序列数，最终会获得重复的序列数

原子类

AtomicInteger（乐观锁的原理），AtomicLong，AtomicReference等特殊的原子性变量类，提供以下形式的原子性条件更新操作：boolean comparaAndSet（expectedValue，updateValue）；
类似boolean，进行原子操作，没有中间状态

public class AtomicIntegerTest implements Runnable {
    private AtomicInteger i = new AtomicInteger(0);//给定了初始值
    private int getValue(){return i.get();}//获取当前值
    private void evenIncrement(){
        i.addAndGet(2);}//以原子方式将给定值添加到当前值,返回更新后的值
    @Override
    public void run() {
        while (true) {
            evenIncrement();
        }
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        final AtomicIntegerTest ait = new AtomicIntegerTest();
        exec.execute(ait);
        while (true) {
            int val = ait.getValue();
            if (val % 2 != 0) {//原子操作没有中间变换的状态，所以不会出错的
                System.out.println(val);
                System.exit(0);
            }
        }
    }
}