多线程

创建线程的三种方式

1.继承thread。
2.实现runnable接口。
3.实现callable接口，使用futureTask接口包装线程调用之后的返回值。如果任务完成Future.get返回结果，否则将阻塞直到进入完成状态。

wait()和sleep()方法的区别

1.wait()是object类的方法，会让线程阻塞并让出锁,获得锁之后会继续往下执行，wait()99%会跟while一起使用而不是if。
2.sleep()方法Thread类的静态方法，让线程阻塞但是不会让出锁。

synchronized关键字

synchroniezd锁定的是对象

    public void t1(){
        synchronized (this){

        }
    }

简写为

    public synchronized void t2(){

    }

当方法为静态时，锁定的整个类

    public static void t3(){
        synchronized (duotai.class){

        }
    }

同步方法和非同步方法能否同时执行

可以

对写方法加锁，读方法不加锁，会产生什么问题？

会产生脏读，即读取到了还没有写完的数据。

一个同步方法可以调用另一个同步方法吗？

可以，synchronized是可重入的，在同一个线程中，已经拥有了某个对象的锁，再次申请依然可以得到这把锁，而且子类的同步方法可以调用父类的同步方法。

程序执行过程中，如果出现异常，锁会释放吗？

会

volatile关键字

作用

保证内存可见性，禁止重排序
重排序：在单线程中，代码可能不会按照写的顺序执行，只要不对结果产生影响，即使在多线程中会产生混乱。

如下代码，在主线程中修改被volatile修饰的f，可以使另一个线程正常结束

public class T  {
    volatile boolean f = true;
    public static void main(String[] args) {
        T t = new T();
        new Thread(()->t.m1(),"t1").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.f = false;
    }
    public void m1(){
        System.out.println("m1...start");
        while (f){

        }
        System.out.println("m1...end");
    }
}

原理

当线程t1开始运行时，从堆内存读取到t对象的f值到自己的工作区，每次使用f的时候只会使用自己工作区中的f，所以当另一个线程改变f的值的时候，t1感知不到。
但是使用volatile关键字之后，如果f的值改变，强制t1从堆内存重新读取f。

volatile和synchronized的区别

volatile只保证可见性，synchronized既保证可见性，也保证原子性。

Lock接口替代synchronized

lock接口的方法
Lock可以尝试获取锁，获取不到程序可以做出其他反应，如果抛出异常，会使锁得不到释放，所以要在finally中加入unlock操作。

        Lock lock = new ReentrantLock();
        try {
            boolean b = lock.tryLock(5, TimeUnit.MINUTES);
            if (b){
                //do something
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

Lock可以调用lockInterruptibly()方法，也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。

lock.lockInterruptibly();

ReentrantLock可以指定为公平锁，synchronized为不公平锁，
在公平锁上，线程按照他们发送请求的顺序来获得锁，但在非公平锁上，则允许插队。非公平锁的性能远高于公平锁的性能，公平性将由于挂起线程和恢复线程时（等待某些挂起和恢复缓慢的线程）存在的开销而极大地降低性能。

 Lock lock = new ReentrantLock(true);

ReentrantLock实现了标准的互斥锁，每次只有一个线程持有ReentrantLock，互斥避免了读写、写写冲突，同样也避免了读读冲突。在许多情况下，数据都是读读操作，这种情况下就可以使用读写锁ReadWriteLock，一个资源可以同时被多个读访问，或者被一个写访问。

threadLocal确保线程的封闭性

threadLocal保证了多线程情况下各个线程之间的变量互相隔离，相互独立，threadLocal提供了get和set访问器，get总是返回由当前线程set的最新值。
ThreadLocal最简单的实现方式就是ThreadLocal类内部有一个线程安全的Map，然后用线程的ID作为Map的key，实例对象作为Map的value，这样就能达到各个线程的值隔离的效果。

不加锁实现线程安全的单例模式

即使用内部类的形式，在初始化内部类的时候，会保证线程安全

public class Singleton    
{    
    private static class SingletonHolder    
    {    
        public final static Singleton instance = new Singleton();    
    }    
   
    public static Singleton getInstance()    
    {    
        return SingletonHolder.instance;    
    }    
}

CAS

乐观锁的一种实现方式，保证多个线程同时修改某个值得时候，只有一个线程可以成功，比较内容地址和预期值，如果相等则修改内存地址为更新值，否则啥也不做。伪代码如下

if (this == expect) {
     this = update
     return true;
 } else {
     return false;
 }

ABA问题
一个线程的this等于A，另一个线程读取this为A，改为B，又改为A，此A非彼A。

AQS

AbstractQueuedSynchronizer 抽象排队同步器
如果当前线程请求的共享资源空闲，则将该资源分配给当前线程，并且将该共享资源设置为锁定状态。
如果当前线程请求的共享资源被锁定，则将当前线程加入队列中。
AQS组件

Semaphore(信号量)-允许多个线程同时访问： synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。
CountDownLatch （倒计时器）： CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。
CyclicBarrier(循环栅栏)： CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

多线程