1、线程基础

1.1 创建线程的几种方式

继承Thread 类，覆盖run方法
实现Runable接口。实现run方法。然后通过Thread类构造方法获取Thread对象。
实现Callable接口。实现call方法。 call方法可以抛出异常。也可以有返回值。
run与start 调用run方法任然是主线程在执行。调用start才会启动多线程

public class A {
    static class MyCall implements Callable<String> {
        @Override
        public String call() throws Exception {
            System.out.println(Thread.currentThread().getName());
            return "call";
        }
    }

    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<>(new MyCall());
        Thread thread = new Thread(futureTask, "T1");
        thread.start();
        //主线程会阻塞，直到futureTask线程执行完获取到返回结果才会继续执行
        String s = futureTask.get();
        System.out.println(s);
    }
}

1.2 Thread的几个常用方法

Thread.sleep(ms) 当前线程执行等待操作。xxx毫秒后继续执行。
Thread.yield() 当前线程放弃当前时间片。(有可能下个时间片还是给到当前线程)
t1.join() 当前线程等待。执行t1线程。直到t1线程执行完成再执行当前线程。
wait notify ????

1.3 线程之间的状态转化

新建刚new出来的线程出于这个状态
ready 调用start方法，但是还未获取时间片
running 调用start方法，且未获取时间片
TimeWaiting 嫌弃等待调用 sleep方法
Waiting 无限期等待调用join方法 wait方法
block 阻塞。等待锁标记
Teminated 终止状态。该状态不可逆

1.4 synchronized 同步锁

对方法或者代码块进行加锁。加锁的方法或者代码块同一个时间段只允许一个线程访问
加在普通方法上等价于对this进行加锁
加在静态方法上等价于对类对象进行加锁
synchronized并不能解决乱序问题
偏向锁
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
轻量级
轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
重量级锁
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
异常锁：synchronized 锁代码块发生异常时会释放锁标记。

public class A {
    /**
     * 可重入锁验证
     */
    public static void main(String[] args) throws Exception {
        A a = new A();
        Thread t1 = new Thread(() -> a.m1(), "t1");
        Thread t2 = new Thread(() -> a.m1(), "t2");
        t1.start();//m1,m2都是同一把锁。所以t1都可以访问
        t2.start();//t2 一直在等待
    }

    synchronized void m1() {
        while (true) {
            System.out.println("m1----" + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            m2();
        }
    }

    synchronized void m2() {
        System.out.println("m2----" + Thread.currentThread().getName());
    }
}

1.5 volatile

保证线程可见性

堆空间中的成员变量是线程共享的。当线程要修改这个变量时需要先把值copy到自己的工作内存中(操作数栈)。待修改完成后再写回去。在这期间若变量的值被别的线程改变。就会影响数据的一致性。
添加volatile关键字时。jvm在编译时会通过 ACC_VOLATILE标记
jvm层面通过读写屏障 cpu层面通过MESI协议保证线程的可见性。
volatile并不能保证原子性

volatile内存区的读写都加屏障
StoreStoreBarrier
volatile 写操作
StoreLoadBarrier
LoadLoadBarrier
volatile 读操作
LoadStoreBarrier

单例模式的双重检查

public class AAA {
    private static AAA a;

    public static AAA getInstance() {
        if (a == null) {
            synchronized (AAA.class) {
                if (a == null) {
                    a = new AAA();
                }
            }
        }
        return a;
    }
}

以上代码虽然加了锁但是任然会存在问题。有可能AAA在刚完成初始化的时候就把引用指向了A。这个时候其他线程就可能得到未初始化的对象。因此要给属性a 加volatile 关键字。禁止指令重排序。

CAS锁，乐观锁

jdk实现 AtomicXXXX 比如 AtomicInteger 通过compareandSet执行修改操作。先比较再赋值。
cas实现原理。

cas的计算会有三个值 v Expected newValue
V就是操作变量的当前值 Expect是期望值即执行运算之前的值。 newValue就是执行运算之后的值。当前两个值相同时。写入新的值否则就要更新Expected的值然后进行重试。

ABA问题

如果是基本类型无影响。
如果是引用类型。可以通过添加版本号来实现。每次修改version加一。AtomicStampedReference实现。
AQS:

ReentrantLock

同synchronized一样都是可重入锁。，他的底层是CAS锁。

与synchronized区别：
- synchronized发生异常以后会自动释放锁。reentrantLock不会。需要手动释放。
- ReentrantLock可以使用tryLockf方法。无论是否取得锁不影响后续操作。
- 可打断。加锁时选择lockInterruptibly方法加锁。可以使用interrupt方法打断其他线程强制占有锁
- 公平锁 (ReenttrantLock 默认是不公平锁，所有等待的线程一起抢锁。没有先来后到) ReentrantLock lock=new ReentrantLock(true) 开启公平锁。谁先来谁先拿到锁。

CountDownLatch

相当于一个同步器。在创建CountDownLatch的时候指定线程数量。每个线程完成的时候调用一下countDown方法。然后可以使用await()方法阻塞线程。等所有线程结束后才继续执行。

    public static void main(String[] args) throws Exception{
        CountDownLatch countDownLatch = new CountDownLatch(100);
        Thread [] threads=new Thread[100];
        for (int i = 0; i < threads.length; i++) {
            threads[i]=new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"  is running");
                countDownLatch.countDown();
            },"thread-"+i);
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        countDownLatch.await();//线程会在该地方阻塞。直到所有线程执行完毕才会打印over
        System.out.println("over");
    }

CyclicBarrier

线程栅栏。定义时会指定围栏大小。如果线程执行过程中调用了await方法。该线程就会等待直到等待线程达到栅栏指定的阈值

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
public class CyclicBarrierTest {
    public static void main(String[] args) {
        //指定等待线程的大小。如果没有那么多的线程。那么将永远阻塞
        CyclicBarrier barrier = new CyclicBarrier(100, () -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("发车了");//该代码由到达阈值的线程执行。
        });
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"is running");
                    TimeUnit.SECONDS.sleep(2);
                    barrier.await();//等运行的线程数到达阈值才会继续执行
                    System.out.println(Thread.currentThread().getName()+"is running");//等队列满了才会执行此代码
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },"thread-"+i).start();
        }
    }
}

LockSuport

# AQS队列(AbstractQueuedSynchronizer)
>- AQS队列又被称为CLH队列它由一个状态值 `volatile int state`和一个`双向链表`组成。state由多个线程抢占。谁拿到这个status就表示谁抢占到这把锁。AQS的核心就是一个共享数据，一堆线程去相互抢夺占用。这个就是AQS
>- 在reentrantLock中当`getStatus()`为1时表示锁已经被占用。0表示没有被占用。
>- 双向表中的node节点存储的是要抢占节点的线程。
>- 当发现status为1时会加入队列中（`addWaiter()`）等待锁释放以后再去抢占锁。
>- 当获取到status为0时，用cas锁尝试将status值设置为1.如果成功掉用setExclusiveOwnerThread.吧当前线程设置为独占这把锁的状态。

# ThreadLocal
>多个线程访问ThreadLocal中的变量。只能获取到他自己set的数据。
## 1、ThreadLocal源码解析
```java
public void set(T value) {
	//获取当前线程
	Thread t = Thread.currentThread();
	//通过当前线程获取对应map 这里的map对象对应 Thread.threadLocals 
	//它是一个Map<ThreadLocal,<T>>其中 T是要存储的数据。
	//一个线程可以绑定多个ThreadLocal对象。
	ThreadLocalMap map = getMap(t);
	if (map != null)
		//key为threadLocal对象，value为存储的值
		//如果之前set过会被覆盖
		map.set(this, value);
	else
		//没有则创建一个新的map
		createMap(t, value);
}

//很简单一目了然
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}
//没有就新创建一个
void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}

public T get() {
	//获取当前线程
	Thread t = Thread.currentThread();
	//获取 t.threadLocals 
	ThreadLocalMap map = getMap(t);
	//如果之前设置过 t.threadLocals应该不为空
	if (map != null) {
		//t.threadLocals的格式 Map<ThreadLocal,<T>>
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			@SuppressWarnings("unchecked")
			T result = (T)e.value;
			return result;
		}
	}
	//返回默认值具体默认值由子类的initialValue方法实现。可自定义
	return setInitialValue();
}