阿里内部Java多线程资料整理

/*
 * 对于第一条原则:对变量的写操作不依赖于当前值;
 * 虽然i++只有一条语句,实际上这条语句是分三步执行的,读入i,i加1，写入i;
 * 若在第三步执行过程前，其他线程对i进行了改动，此时的结果将是错的。因此即使使用了volatile进行控制，并不能保证这个操作是线程安全的。
*/

private volatile int i=1;
... 
i++;

/*
 * 这类问题的解决方案有两种: 
 * 1.一种是采用synchronized进行同步控制，这显然违背了volatile的初衷
 * 2.一种是采用CPU原语进行控制。在jdk1.5之后，java.util.concurrent.atomic包下的很多类就是采用这种方式进行控制，这样可以在保持性能的情况下，保证数据的线程安全。
 */

/*
 * 如下代码所示: 
 * 虽然Vector是一个线程安全的类，但是对于由Vector线程安全的方法组成上面的逻辑，显然不是线程安全的。 
 * 当然，由线程不安全的类构成的程序，也不一定不是线程安全的。
 */

Vector v;
 
if(!v.contains(o)){
v.add(o);
}

/*
 * 微妙的可见性:
 * 当变量的读入写出被不同的线程共享时，必须使用同步。若不使用同步将有可能发生与直觉大相径庭的错误。
 */
public class TestVisiable {

    static int x = 0, y = 0;
    static int b = 0, a = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                a = 1;
                x = b;
            }
        });
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                b = 1;
                y = a;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(x + " " + y);
    }
}

/*
 * 由于没有同步，程序运行的可能结果为(1,0) (0,1),(1,1),然而，还有可能为(0,0),不可思议吧。 
 * 1.这是由于为了加快并发执行，JVM内部采用了重排序的机制导致。
 * 2.最低限的安全性在java中，java存储模型要求java变量的获取和存储都是原子操作，但是有两种类型的变量是比较特殊的,没有申明为volitale的long和double变量。 
 * 原因在于：
 * 1.在java中long和double变量为64位，jvm允许将64位的读写操作划分为两个32位的操作。
 * 2.当多个线程同时读写非volatile的long或者double类型数据时，将有可能得到数据是一个数的高32位和另一个数的低32位组成的数。
 * 3.这样的结果显然是完全不对的。因此对应long或double类型的数据用于多线程共享时，必须申明加上volatile或者进行同步。
 */

/*
 * 下面给出一个详细的应用场景 百米赛跑：
 * 比赛共有10名运动员参与，10名运动在起跑线上统一等待号令员发起起跑的号令，通过终点时号令员统计该运动员的时间，当所有运动员都跑到终点时，报告每个人的成绩。
 * 这里实际上就可以采用CountDownLatch来解决起跑线上设置一个CountDownLatch，当号令员没有发起起跑号令时，所有运动员都在起跑线上等待。
 * 在终点设置一个CountDownLatch，起跑后号令员一直等待，当所有运动员都通过终点后，它会报告成绩。 用代码实现如下：
 */

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

public class Commander {

    private final CountDownLatch     startSignal;                            // 起跑信号
    private final CountDownLatch     endSignal;                              // 终点信号
    private Long                     startTime;
    private final Map<Integer, Long> scoreMap = new HashMap<Integer, Long>();

    public void waitStart() {
        try {
            startSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void start() {
        startTime = System.currentTimeMillis();
        startSignal.countDown();
        try {
            endSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void reach(int id) {
        endSignal.countDown();
        scoreMap.put(id, System.currentTimeMillis() - startTime);// 统计时间
    }

    public Commander(int num){
        startSignal = new CountDownLatch(1);
        endSignal = new CountDownLatch(num);
    }

    public static void main(String[] args) {
        int runnerNum = 10;
        Commander c = new Commander(runnerNum);
        for (int i = 0; i < runnerNum; i++) {
            new Thread(new Runner(i + 1, c)).start();
        }
        c.start(); // 发起号令
        for (Integer i : c.scoreMap.keySet()) {
            System.out.println(i + "号运动员,耗时" + c.scoreMap.get(i));
        }
    }
}

class Runner implements Runnable {

    Commander commander;
    int       id;

    public Runner(int id, Commander commander){
        this.id = id;
        this.commander = commander;

    }

    @Override
    public void run() {
        commander.waitStart();
        try {
            Thread.sleep((long) (Math.random() * 1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        commander.reach(id);
    }
}

/*
 * 考虑一个应用场景： 
 * 老师带领学生去春游，下午回来时，需要整队，然后统一坐车回去。 
 * 在这里，老师和已经到达的学生，必须等待所有学生归队后才能回去。 用代码实现如下：
 */

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Teacher {

    private final CyclicBarrier barrier = new CyclicBarrier(20, new Runnable() {

                                            @Override
                                            public void run() {
                                                System.out.println("所有学生已经归队");
                                            }
                                        });

    public void comeBack(int i) {
        System.out.println(i + "已经归队。");
        try {
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Teacher t = new Teacher();
        for (int i = 0; i < 20; i++) {
            new Thread(new Student(i + 1, t)).start();
        }

    }
}

class Student implements Runnable {

    private final int     id;
    private final Teacher teacher;

    public Student(int id, Teacher teacher){
        this.id = id;
        this.teacher = teacher;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((long) (Math.random() * 1000));
            teacher.comeBack(id);
            System.out.println(id + "上车");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

/* 它有以下具体实现类：
 * ArrayBlockingQueue：采用数组作为存储队列的阻塞队列，这个队列采用FIFO的方式管理数据
 * LinkedBlockingQueue：采用链式结构作为存储队列，同样它也采用FIFO的方式管理数据
 * PriorityBlockingQueue：采用基于优先级堆的极大优先级队列作为存储队列。
 * SynchronousQueue：特殊的BlockingQueue，其中每个 put 必须等待一个 take，反之亦然。
 * DelayQueue：这是一个无限阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部。
 * 
 * 通过查看源代码可以看到这个类内部是采用PriorityQueue作为存储队列
 * DelayQueue的一些常用的场景
 * a) 关闭空闲连接。服务器中，有很多客户端的连接，空闲一段时间之后需要关闭之。
 * b) 缓存。缓存中的对象，超过了空闲时间，需要从缓存中移出。
 * c) 任务超时处理。在网络协议滑动窗口请求应答式交互时，处理超时未响应的请求。
 * */

void execute(Runnable command);

public interface Callable<V> {
　　V call() throws Exception;
}

private final Executor executor;
private final AbstractExecutorService aes;
private final BlockingQueue<Future<V>> completionQueue;

private class QueueingFuture extends FutureTask<Void> {
        QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;
    }

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}