并发（一）

这个月，总结一下thread的相关知识，把基础知识弄得更牢固一下，学习先增加深度在扩展广度。

声明：文章内容以及部分代码示例，参考了《Thinking in Java》（Java编程思想）这本书。

该书绝对是java从业人员的宝典之一。强烈推荐。

1 并发

并发通常是提高运行在单处理器上的程序的性能。

一般它或提高程序执行效率，或为设计某些类型的程序提供更易用的模块，或两者都有。

 在这里说一下线程安全的概念，多线程访问同一代码，不会产生不确定的结果，这样的话我们就说线程是安全的。

2 基本线程机制

2.1 定义任务，创建线程

一般是两种方式，一是继承一个thread类，另一种是实现Runnable接口。

下面给出代码示例：

public class LiftOff implements Runnable{

    protected int countDown = 10;
    private static int taskCount = 0;
    // 标识符id可以用来区分任务的多个实例，它是final的，
    // 因为它一旦被初始化之后就不希望被修改
    private final int id = taskCount++;
    public LiftOff() {}
    public LiftOff(int countDown) {
        
    }
    public String status() {
        return "#" + id + "(" + 
    (countDown > 0 ? countDown : "LiftOff") + ").";
    }
    public void run() {
        
        while(countDown-- > 0){
            System.out.println(status());
            Thread.yield();
        }
    }
}

public class ThreadDemo01 extends Thread{
    public static void main(String args[]){
        LiftOff lift = new LiftOff();
        lift.run();
    }
}

public class ThreadDemo02 extends Thread{
    public static void main(String args[]){
        Thread thread = new Thread(new LiftOff());
        thread.start();
    }

}

执行结果如下：

#0(9).
#0(8).
#0(7).
#0(6).
#0(5).
#0(4).
#0(3).
#0(2).
#0(1).
#0(LiftOff).

大家查看API会发现，Thread类继承了Runnable接口，所以，线程最终是通过Runnable接口来实现的。推荐使用Runnable接口的方式，因为这样它还可以继承其它的类，增加自身的灵活性。

下面给出一个驱动多线程的示例：

public class ThreadDemo03 {

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            new Thread(new LiftOff()).start();
        }
    }

}

2.2 使用Executor

书中写明，在JAVA 6中，Executor是启动任务的优选方法，但是目前在JAVA 8中，是不是优选，我不知道。

Executor相当于客户端和线程之间的一个桥梁，由它执行任务。

常用的Executor有newCachedThreadPool（首选）， FixedThreadPool（需指定线程数量）， SingleThreadExcutor等。

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

public class ThreadDemo04 {
    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        
        // ExecutorService service = Executors.newFixedThreadPool(2);
        // ExecutorService service = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 5; i++) {
            service.execute(new LiftOff());
        }
        // shutDown方法，拒绝接受新的任务。我认为类似于io的close
        service.shutdown();
        System.out.println("------------");
    }
}

2.3 从任务中产生返回值

Runnable只能执行任务，不能返回结果和异常。为了返回结果，可以实现Callable接口。

代码示例如：

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadDemo06 {

    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();
        List<Future<String>> list = new LinkedList<Future<String>>();
        for (int i=0 ; i< 10 ; i++){
            list.add(service.submit(new TaskWithResult(i)));
        }
        for (Future<String> fs : list) {
            try {
                // get方法会或许返回值，如果任务尚未执行结束，会一直等待，造成阻塞
                // 可以用isDone方法来判断，任务是否执行结束
                System.out.println("future done? " + fs.isDone());
                System.out.println(fs.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
                return;
            } finally {
                service.shutdown();
            }
        } 
    }
}

class TaskWithResult implements Callable<String> {

    private int id;
    public TaskWithResult (int id) {
        this.id = id;
    }
    @Override
    public String call() throws Exception {
        return "result of TaskWithResult " + id;
    }
}

执行结果：

future done? true
result of TaskWithResult 0
future done? true
result of TaskWithResult 1
future done? true
result of TaskWithResult 2
future done? true
result of TaskWithResult 3
future done? true
result of TaskWithResult 4
future done? true
result of TaskWithResult 5
future done? true
result of TaskWithResult 6
future done? true
result of TaskWithResult 7
future done? true
result of TaskWithResult 8
future done? true
result of TaskWithResult 9

2.4 后台线程

所谓后台线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的后台线程结束时，程序也就终止了，同时杀死进程中的所有后台线程。（摘自《Java编程思想》第21章）

代码示例如下：

import java.util.concurrent.TimeUnit;

public class SimpleDaemons implements Runnable {

    @Override
    public void run() {

        while (true) {
            try {
                TimeUnit.MICROSECONDS.sleep(100);
                System.out.println(Thread.currentThread() + " " + this);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("sleep() intertupted");
            }
        }
    }
    
    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.MICROSECONDS.sleep(175);
    }
}