JAVA基础：线程

1.创建线程

几种常见方式：

Callable：有返回值

Runnable：最常用的没有返回值

Future：接口，submit的返回值，可以中断、查询线程和结果

FutureTask：实现了Runnable和Future，同时有两种构造参数：

public FutureTask(Callable<V> callable) {

}

public FutureTask(Runnable runnable, V result) {

}

Executors/ ExecutorService：线程池的创建（内部是ThreadPoolExecutor实现的）

ThreadPoolExecutor：线程池的创建

ExecutorService executorService = Executors.newCachedThreadPool();
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        return null;
    }
});

FutureTask<Integer> futureTask1 = new FutureTask<Integer>(new Runnable() {
    @Override
    public void run() {

    }
}, 3);

executorService.submit(futureTask);
executorService.submit(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        return null;
    }
});

new Thread(new Runnable() {
    @Override
    public void run() {
        
    }
}).start();

2.其他线程相关类

ThreadLocal：

用处：保存线程的独立变量。对一个线程类（继承自Thread)
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。常用于用户登录控制，如记录session信息。

实现：每个Thread都持有一个TreadLocalMap类型的变量（该类是一个轻量级的Map，功能与map一样，区别是桶里放的是entry而不是entry的链表。功能还是一个map。）以本身为key，以目标为value。
主要方法是get()和set(T a)，set之后在map里维护一个threadLocal -> a，get时将a返回。ThreadLocal是一个特殊的容器。

原子类（AtomicInteger、AtomicBoolean……）

如果使用atomic wrapper class如atomicInteger，或者使用自己保证原子的操作，则等同于synchronized

AtomicReference 与AtomicInteger 区别：泛型对象
对于AtomicReference 来讲，也许对象会出现，属性丢失的情况，即oldObject == current，但是oldObject.getPropertyA != current.getPropertyA。
这时候，AtomicStampedReference就派上用场了。这也是一个很常用的思路，即加上版本号 

3.同线程步

 Lock：

ReentrantLock /ReentrantReadWriteLock.ReadLock /ReentrantReadWriteLock.WriteLocklock

更灵活，可以自由定义多把锁的枷锁解锁顺序（synchronized要按照先加的后解顺序） 提供多种加锁方案，lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式， 还有trylock的带超时时间版本。 本质上和监视器锁（即synchronized是一样的） 能力越大，责任越大，必须控制好加锁和解锁，否则会导致灾难。 和Condition类的结合。

4.容器类

java.concurrent:

BlockingQueue ：ReentrantLock实现同步

ConcurrentHashMap： 对应的数组中的Segment对象(继承自ReentrantLock)实现同步

CopyOnWriteArrayList： ReentrantLock实现同步

非java.concurrent包:

Vector /HashTable  synchronized实现

 5.中断线程

stop遭到弃用。Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。 

因此，如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用interrupt()（注意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最后线程都将检查共享变量然后再停止 

建议采用的方式共享变量/socket

参考：https://blog.csdn.net/hjiacheng/article/details/73277254

6.conditionvariable

Android给我们封装好了一个ConditionVariable类，用于线程同步。提供了三个方法block()、open()、close()。
void block()
阻塞当前线程，直到条件为open
void block(long timeout)
阻塞当前线程，直到条件为open或超时
void open()
释放所有阻塞的线程
void close()
将条件重置为close

7.线程池

newFixedThreadPool()
说明：初始化一个指定线程数的线程池，其中corePoolSize == maxiPoolSize，使用LinkedBlockingQuene作为阻塞队列
特点：即使当线程池没有可执行任务时，也不会释放线程。
newCachedThreadPool()
说明：初始化一个可以缓存线程的线程池，默认缓存60s，线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；
特点：在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源；当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；
因此，使用时要注意控制并发的任务数，防止因创建大量的线程导致而降低性能。
newSingleThreadExecutor()
说明：初始化只有一个线程的线程池，内部使用LinkedBlockingQueue作为阻塞队列。
特点：如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行
newScheduledThreadPool()
特定：初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。

总结：除了newScheduledThreadPool的内部实现特殊一点之外，其它线程池内部都是基于ThreadPoolExecutor类（Executor的子类）实现的。

其中AtomicInteger变量ctl的功能非常强大：利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态：
1、RUNNING：-1 << COUNT_BITS，即高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
2、SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
3、STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
4、TIDYING ： 2 << COUNT_BITS，即高3位为010，该状态表示线程池对线程进行整理优化；
5、TERMINATED： 3 << COUNT_BITS，即高3位为011，该状态表示线程池停止工作；

 提交任务executor无返回值，submit返回带结果的Future对象

 8.线程状态转换

 持有锁的线程会释放锁：
    1. 执行完同步代码块。
    2. 在执行同步代码块的过程中，遇到异常而导致线程终止。
    3. 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进行对象的等待池。
    除了以上情况外，只要持有锁的此案吃还没有执行完同步代码块，就不会释放锁。因此在以下情况下，线程不会释放锁：
    1. 在执行同步代码块的过程中，执行了Thread.sleep()方法，当前线程放弃CPU，开始睡眠，在睡眠中不会释放锁。
    2. 在执行同步代码块的过程中，执行了Thread.yield()方法，当前线程放弃CPU，但不会释放锁。
    3. 在执行同步代码块的过程中，其他线程执行了当前对象的suspend()方法，当前线程被暂停，但不会释放锁。但Thread类的suspend()方法已经被废弃。

    4.在执行同步代码块的过程中，执行了Thread.join()方法，进入wait状态，但不释放锁

9.LockSupport

LockSupport比Object的wait/notify有两大优势：

①LockSupport不需要在同步代码块里 。所以线程间也不需要维护一个共享的同步对象了，实现了线程间的解耦。

②unpark函数可以先于park调用，所以不需要担心线程间的执行的先后顺序。

 LockSupport的内部是调用的Unsafe的函数