Java 多线程

1 简述

1.1 线程机制

Java使用的是抢占式的线程机制，调度机制周期性地切换上下文，切换线程，从而为每个线程提供时间片。看似同时执行，其实是不停地切换。在这种机制下，一个线程的阻塞不会导致整个进程阻塞。

优先级较低的线程仅仅是执行的频率较低，不会得不到执行。

要实现线程行为，你必须显示地将一个任务（Runnable）附着到线程（Thread）上。Thread类只是驱动赋予它的任务Runnable。

1.2 阻塞（se第四声）

程序中一个任务因为该程序控制范围外的因素（条件通常是IO），而不能继续执行，这个任务线程被阻塞了。

2 Executor 线程池

用new Thread()的方式不利于性能优化，所以采用线程池替代，达到线程的复用。首选CachedThreadPool回收旧线程停止创建新线程。

ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new Runnable() {
        @Override
        public void run() {

        }
});

Runnable设返回值，需要实现Callable接口call()方法，并且必须使用ExecutorService.submit()方法调用。
使用 Future.get() 获取返回值。
例如：

public class CallableAndFuture {
    static class MyThread implements Callable<String> {
        @Override
        public String call() throws Exception {
            return "Hello world";
        }
    }

    static class MyThread2 implements Runnable {
        @Override
        public void run() {

        }
    }

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<String> future = threadPool.submit(new MyThread());

        try {
            System.out.println(future.get());
        } catch (Exception e) {

        } finally {
            threadPool.shutdown();
        }
    }
}

3 线程安全

3.1 实质

线程安全其实就是解决共享资源竞争的问题。
解决方法是：当一个资源被一个任务使用时，加锁。

解锁的时候，下一个要使用资源的任务并没有按照排队的方式按次序来获取，而是通过竞争获取资源。可以通过yield()和setPriority()来给线程调度器提供建议，这效果取决于具体平台和JVM实现。

3.2 synchronized加锁

对于某个特定对象，其所有的synchronized方法共享同一个锁。
一个任务可以多次获得对象的锁。

判断是否应该加锁：如果你正在写一个变量，这个变量接下来将被另一个线程读取；你正在读一个上一次已经被另一个线程写过的变量。以上两种情况都必须使用同步。并且，读写线程都必须用相同的监视器锁同步。

3.3 使用显式的Lock对象加锁

除了synchronized方式加锁之外，还可以用Lock对象：

private Lock lock = new ReentrantLock();//重入锁
......
lock.lock();
try{
......
return ...;//在try中return确保unlock()不会过早发生
}finally{
lock.unlock();
}

和synchronized的区别：tryLock()

可以尝试着获取锁，最终获取失败。
可以尝试着获取锁一段时间，然后放弃获取。

如果其他的线程已经获取了这个锁，你可以决定离开，去执行其他一些事，而不是等待直至这个锁释放。提供了比Synchronized更细粒度的控制力。（例如可以释放当前锁之前，捕获下一节点的锁）

4 volatile

volatile关键字主要提供2种作用：

可见性：当使用volatile关键字去修饰变量的时候，所有线程都会直接读取该变量并且不缓存它。这就确保了线程读取到的变量是同内存中是一致的
禁止指令重排序：应用在标志位

5线程本地存储

防止共享资源产生冲突的第二种方式是根除变量的共享，使用ThreadLocal。

6 终结任务

线程的各个状态

停止线程主要使用标志位，在run()方法中加以判断，是否要执行。

自己定义一个volatile boolean的标志位
使用interrupt()方法，但是这个方法也是打个停止的标志，并不是真正的停止线程，还是要在run()方法中调用Thread.interrupted()方法判断。

7 线程之间的协作

yield()方法：调用的线程放弃cpu时间让给别的线程。
join()方法：调用的线程先执行。

7.1 wait()

wait()是object的方法，它会释放锁，而sleep()和yield()不会释放。
因此在该对象（未锁定的）中的其他synchronized方法可以在wait()期间被调用。

只能在同步控制方法或者同步控制块里调用wait()、notify()、notifyAll()，因为要操作对象的锁。

wait()必须用一个检查感兴趣的条件的while循环包围，本质是检查感兴趣的条件，并在条件不满足的情况下返回到wait()方法中。

Thread1:
synchronized(sharedMonitor){
  <setup condition for Thread2>
  sharedMonitor.notify();
}
//错误的使用:时机太晚，错失信号，盲目进入wait()，产生死锁。
Thread2:
while(someConditon){
  synchronized(sharedMonitor){
    sharedMonitor.wait();
  }
}
//正确的使用：防止在someCondition变量上产生竞争条件
Thread2:
 synchronized(sharedMonitor){
    while(someConditon){
         sharedMonitor.wait();
    }
 }

7.2 notify()和notifyAll()

notify()：在众多等待同一个锁的线程中，只有一个会被唤醒去获取锁。
notifyAll()：在众多等待同一个锁的线程中，全部会被唤醒去共同竞争锁。
两个同样最终只有一个线程能获取到锁。

可能有多个线程在某单个对象上处于wait状态，因此调用notifyAll()比notify()更安全。
只有一个线程实际处于wait()状态，这时可以用notify()代替notifyAll()优化；

如果有多个线程在等待不同条件，使用notify()就不能知道是否唤醒了恰当的任务。

8 死锁

某个线程在等待另一个线程，而后者又在等待别的线程，这样一直下去，直到这个链上的线程又在等待第一个线程释放锁。这得到了一个状态：线程之间相互等待的连续循环，没有哪个线程能继续。这被称为死锁

死锁的4个条件：

互斥条件（资源的特点）：线程使用的资源中至少有一个是不能共享的。
占用请求条件（单个线程的特点）：至少有一个线程，它持有一个资源，并且等待获取另一个当前被别的线程持有的资源。
不可剥夺条件（单个线程的特点）：已持有的资源不能被别的线程抢占，而它（持有资源的线程）自己也不会主动去抢别的线程的资源。
循环等待条件（多个线程形成的特点）：必须有循环等待。

解决：让一方先放弃资源作出让步。