Java编程思想(十七) —— 并发之基本概念和方法

先提前写并发这一块，前面的数组，IO，泛型，注解是知识点很多很小的东西，放到后面写。

确实如书上所说，学到这里都是顺序编程，程序所有事物任意时刻只能执行一个步骤。这远远不够，想想双11淘宝技术如果并发不牛叉的话根本处理不了这么 庞大的数据量。——《淘宝技术这十年》。技术的积累真的是很深。

作者介绍的时候最后很有趣说，学会这章之后很容易变得过分自信，如果要学好，还需要继续深入。

1)基本的线程机制

进程有3种状态，运行，就绪，阻塞。

线程有4种状态，运行，就绪，阻塞和终止。网上还有其他分法。

所谓进程和线程的联系区别，是经常问的问题，回答倒是难答。

简单说的话，一个程序至少有一个进程，而一个进程里面至少有一个线程，线程间共享进程内存空间，而进程与进程间独立。

一、线程驱动任务：

class MyThread implements Runnable{
    //Runnable 源码
    /*public
    interface Runnable {
        public abstract void run();
    }*/
    int number = 10;
    private static int count = 0;
    //之前用过，就是希望id初始化之后不再改变
    private final int id = count++;
    public MyThread(){}
    public MyThread(int number){
        number = number;
    }
    public String status(){
        return id+" "+ (number > 0? number :"zero");
    }
    public void run() {
        while(number-->0){
            System.out.println(status());
            Thread.yield();
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        MyThread m = new MyThread();
        m.run();
    }
}

Thread.yield()是线程调度器，其实就是说我跑过了，我把cpu让给你。

一run，马上就跑了起来。

二、用Thread驱动：

Thread(Runnable target)

Allocates a new Thread object.

public class TestThread {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.start();
        System.out.println("late");
    }
}

start会为线程先做初始化操作，然后调用run方法。此时的run方法是其他线程调用，main线程继续执行，所以先打印出late。当然，如果改成t.run()，那么late就会最后打印了。

Tread的run和start有什么区别呢——java中thread的start()和run()的区别 。

按照里面的英文说法，假如我们再：

public static void main(String[] args) {
        Thread t = new Thread(new MyThread());

        Thread t1 = new Thread(new MyThread());

        t.start();
        t1.start();
        // t.run();
        // t1.run();
        System.out.println("late");
    }
    result：
    start方法：
    1 9
    0 9
    1 8
    0 8
    1 7
    0 7
    1 6
    0 6
    1 5
    0 5
    1 4
    0 4
    1 3
    0 3
    1 2
    0 2
    1 1
    0 1
    1 zero
    0 zero

    run方法：
    0 9
    0 8
    0 7
    0 6
    0 5
    0 4
    0 3
    0 2
    0 1
    0 zero
    1 9
    1 8
    1 7
    1 6
    1 5
    1 4
    1 3
    1 2
    1 1
    1 zero

run和start是不同的，两个线程使用start方法的时候，两个是同时运行的，结果是交错的。

两个线程使用run方法的时候，运行是顺序的，哪个在前，先运行哪个。所以看到的是t的输出先。

start方法会让线程运行是异步的（asynchronously），在启动的时候，其实start调用的是MyThread的run方法，但是此时执行的是其他线程，而执行main方法的线程继续，所以先打印了df，其余两个线程在交错运行中。

run方法是同步的（synchronously），只有等它运行完才进行下一步的操作，所以df在最后打印。

2)用Executor管理Thread

java.util.concurrentInterface Executor

An object that executes submitted Runnable tasks.  An Executor is normally used instead of explicitly creating threads. For example, rather than invokingnew Thread(new(RunnableTask())).start() for each of a set of tasks, you might use:

 Executor executor = anExecutor;
 executor.execute(new RunnableTask1());
 executor.execute(new RunnableTask2());
 ...

一个执行提交的Runnable任务的类。代替显式地创建线程。

    ExecutorService es = Executors.newCachedThreadPool();
    es.execute(new MyThread());
    es.execute(new MyThread());
    es.shutdown();
  //es.execute(new MyThread()); shutdown之后不能提交新任务

newCachedThreadPool为每个任务都创建一个线程，

ExecutorService es = Executors.newFixedThreadPool(2);
es.execute(new MyThread());

newFixedThreadPool(int n)不会为每个任务都创建一个线程，而是限制了线程，需要线程的事件会到这个池里拿到线程。

newSingleThreadExecutor()的作用就和FixedThreadPool中n的值为1一样。

ExecutorService ess = Executors.newFixedThreadPool(1);
ess.execute(new MyThread());
ess.execute(new MyThread());
ess.execute(new MyThread());
ess.execute(new MyThread());
ess.execute(new MyThread());

0 9
0 8
0 7
0 6
0 5
0 4
0 3
0 2
0 1
0 zero
1 9
1 8
1 7
1 6
1 5
1 4
1 3
1 2
1 1
1 zero
2 9
2 8
2 7
2 6
2 5
2 4
2 3
2 2
2 1
2 zero
3 9
3 8
3 7
3 6
3 5
3 4
3 3
3 2
3 1
3 zero
4 9
4 8
4 7
4 6
4 5
4 4
4 3
4 2
4 1
4 zero

3)从任务中返回值

Runnable虽然执行自己的工作，但是不返回值，实现Callable接口可以返回值。

java.util.concurrent
Interface Callable<V>

Type Parameters:
V - the result type of method call

Modifier and Type	Method and Description
V	call() Computes a result, or throws an exception if unable to do so.

class MyCall implements Callable<String>{
    private int id;
    public MyCall(int id){
        this.id = id;
    }
    public String call() throws Exception {
        return "call"+id;
    }
}

public class ExecuteCall {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        ArrayList<Future<String>> a = new ArrayList<Future<String>>();
        for (int i = 0; i < 5; i++) {
            a.add( es.submit(new MyCall(i)));
        }
        for(Future f : a){
            try {
                System.out.println(f.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

这个例子很多新东西，因为我们是要返回值，所以用了MyCall实现了Call接口，并且必须使用ExecutorService.submit方法。

<T> Future<T>

submit(Callable<T> task) Submits a value-returning task for execution and returns a Future representing the pending results of the task.

返回的是Future对象。

public interface Future<V>

A  Future represents the result of an asynchronous computation.

Future代表的是异步计算的结果。

然后我们用了ArrayList来存储Future，通过foreach语法遍历。

V get()
      throws InterruptedException,
             ExecutionException

Waits if necessary for the computation to complete, and then retrieves its result.

get方法会找回结果。

4)休眠

记得以前看过一个排序算法是用休眠写的，很有趣，至今还记得，就是让大的数睡久一点才输出。

Mythread的修改：

public void run() {
    while(number-->0){
        System.out.println(status());
        try {
            //Thread.sleep(100);
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Thread.sleep是老版本的写法，TimeUnit.MILLISECONDS.sleep是SE5版本后的写法。其实后者也是用了Thread.sleep。

public void sleep(long timeout) throws InterruptedException {
      if (timeout > 0) {
         long ms = toMillis(timeout);
         int ns = excessNanos(timeout, ms);
         Thread.sleep(ms, ns);
      }
}

翻到火龙果的论坛帖子，其实后者和前者的区别就是可以变换单位，

TimeUnit.MICROSECONDS.sleep的话就是微秒，如果1000微秒的话那就是一毫秒，直接可以用TimeUnit.MILLISECONDS.sleep(1)。

这样就提供的更好的阅读性，不是有些题目会问你Thread.sleep方法里面的单位是多少吗？——毫秒。

5)优先级调度

public class TestPriority {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread());
        Thread t2 = new Thread(new MyThread());
        Thread t3 = new Thread(new MyThread());
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}

其实调度的映射做得不是很好，setPriority有10级优先级，1到10，数字越大优先级别越大。映射不好是指4不一定比5慢。

6)让步

让步的话就是前面写到的Thread.yield，给线程调度机制的信息就是我自己已经运行的差不多了，你们谁需要就谁去用吧。

这些是线程的基本概念，优先级，睡眠，之前没用过的就是Executor和TimeUnit.MILLISECONDS.sleep。