目录

• 线程的状态
• 使用线程
• 线程机制
  • 用户线程与守护（Daemon）线程
  • 睡眠
  • yield
• 中断
  • interrupt()
  • interrupted()
  • 中断的应用
• 线程池
• 线程安全的实现方法
  • 不可变
  • 互斥同步
    • synchronized关键字与ReentrantLock
  • 非阻塞同步
  • 无同步
    • 线程本地存储
• 线程之间的协调
  • join
  • wait、notify、notifyAll
    • wait与sleep的区别：
  • await、signal、signalAll
• JUC包
  • AQS
    • CountdownLatch
    • Semaphore
  • 其他组件
    • FutureTask
    • BlockingQueue
• 乐观锁和悲观锁
  • 悲观锁
  • 乐观锁
  • 乐观锁的两种实现
    • 版本号机制
    • CAS
  • 乐观锁的缺点
    • ABA问题
    • 自旋锁开销大
  • CAS与synchronized使用场景
• synchronized和ReenTrantLock的区别

线程的状态

新建（New）、可运行（Runnable）、阻塞（Blocking）、无限期等待（Waiting）、有限期等待（Timed-Waiting）、死亡（Terminated）

使用线程

• 实现Callable接口
• 实现Runnable接口
• 继承Thread类

线程机制

用户线程与守护（Daemon）线程

守护线程时提供通用服务的线程（例如垃圾回收线程），优先级很低
通过Thread对象的setDaemon(boolean)方法设置守护线程与用户线程，注意此方法必须在线程对象的start方法之前调用，否则会抛出java.lang.IllegalThreadStateException异常
守护线程创建的线程默认是守护线程，用户线程同理。
守护线程是为了服务用户线程而存在的，所有用户线程结束之后，jvm就退出了，守护线程自然也结束，所以守护线程的结束时间不确定

睡眠

线程的sleep方法（静态方法），休眠当前线程，当前线程进入timed-waiting状态

yield

线程对象的yield方法表明该线程已经完成了最重要的工作，尝试让出cpu占用，把cpu使用权让给同优先级的其他线程

中断

interrupt()

通过调用线程对象的interrput方法中断该线程，如果该线程处于等待/阻塞状态，会抛出java.lang.InterruptedException异常。
该方法不能中断处于I/O阻塞或synchronized阻塞的线程
线程对象的该方法被调用后，会设置阻断标志为true，通过interrupted()方法检查是否有人调用了本线程的interrupt方法

interrupted()

检查是否有人调用了本线程的interrupt方法

中断的应用

线程池的shutdownNow方法就是通过调用所有工作线程的interrupt方法来中断工作线程

线程池

https://www.cnblogs.com/darknessplus/p/10359256.html

线程安全的实现方法

不可变

互斥同步

synchronized关键字与ReentrantLock

都是可重入锁
synchronized关键字由jvm实现，ReentrantLock由jdk实现
ReentrantLock提供比synchronized更高级的功能

• 等待可中断
• 公平锁
• 选择性通知

非阻塞同步

无同步

线程本地存储

ThreadLocal类
ThreadLocal 不是用来协调多线程的，而是为同一个线程的不同方法提供共享变量。
一个线程的ThreadLocal变量在任何方法内都是可见的
线程Thread保存了ThreadLocalMap，ThreadLocalMap保存了本线程的所有ThreadLocal数据
ThreadLocal提供的方法

public T get() { }
public void set(T value) { }
public void remove() { }
protected T initialValue() { }

线程之间的协调

多线程协作解决问题时，需要对他们的执行顺序进行协调

join

调用另一个线程对象的join方法表示本线程等待另一个线程执行完成后再继续执行

wait、notify、notifyAll

wait、notify是Object类提供的final方法，不可重写。
通过调用某个对象的wait方法，释放本线程对该对象持有的锁，进入阻塞状态。
另一个线程调用该对象的notify方法，唤醒该对象的锁的阻塞队列中的一个线程，notifyAll方法唤醒该对象的等待队列的所有线程。
wait期间，线程会释放锁，不然会死锁。
配合synchronized使用，再同步代码中使用。

wait与sleep的区别：

• wait是Object方法，sleep是Thread的静态方法
• wait会释放锁，sleep不会

生产者消费者问题：

public class Wait {

    public static void main(String[] args) throws InterruptedException {
        LinkedList<Integer> list = new LinkedList<Integer>();
        Factory factory = new Factory();
        factory.setList(list);
        factory.setMaxSize(10);
        for(int i=1;i<=10;i++)
        {
            Producer producer = new Producer();
            producer.setNum(i);
            producer.setFactory(factory);
            producer.start();

            Consumer consumer = new Consumer();
            consumer.setNum(i);
            consumer.setFactory(factory);
            consumer.start();
        }
    }
}
class Producer extends Thread{
    private AbstractFactory factory;
    private int num;

    public void setNum(int num) {
        this.num = num;
    }

    public void setFactory(AbstractFactory factory) {
        this.factory = factory;
    }

    @Override
    public void run() {
        factory.produce(num);
    }
}
class Consumer extends Thread{
    private AbstractFactory factory;
    private int num;

    public void setFactory(AbstractFactory factory) {
        this.factory = factory;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public void run() {
       factory.consume(num);
    }
}
class Factory implements AbstractFactory{
    private List<Integer> list;
    private int maxSize;

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    public void produce(int num) {
        synchronized (list)
        {
            while(num+list.size()>maxSize)
            {
                try {
                    System.out.println("仓库已满。要生产的"+num+"，库存容量"+maxSize);
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            int size=list.size();
            for(int i=size;i<size+num;i++)
            {
                list.add(i);
            }
            System.out.println("生产"+num+"件，总共"+list.size()+"件");
            list.notifyAll();
        }
    }

    public void consume(int num) {
        synchronized (list)
        {
            while(list.size()-num<0)
            {
                try {
                    System.out.println("仓库已空。要消费的"+num+"，库存容量"+list.size());
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            int size=list.size();
            for(int i=size-1;i>=size-num;i--)
            {
                list.remove(i);
            }
            System.out.println("消耗"+num+"件，总共"+list.size()+"件");
            list.notifyAll();
        }
    }
}
interface AbstractFactory
{
    void produce(int num);
    void consume(int num);
}

await、signal、signalAll

对应着Object的wait和notify方法，Lock也有类似的机制。
通过Lock.newCondition()方法获取一个condition对象，通过condition对象的await和signal方法进行线程同步。
在使用condition对象的await和signal方法之前必须获得重入锁，调用signal方法后最好释放重入锁。

JUC包

AQS

CountdownLatch

控制一个线程等待其他线程

public static void main(String[] args) throws InterruptedException {
        final CountDownLatch count = new CountDownLatch(10);
        for(int i=0;i<10;i++){
            new Thread(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                    count.countDown();
                }
            }.start();
        }
        count.await();
        System.out.println("END");
    }

输出：

Thread-0
Thread-2
Thread-3
Thread-1
Thread-5
Thread-4
Thread-6
Thread-7
Thread-8
Thread-9
END

Semaphore

信号量，控制并发线程数

public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(1);
        for (int i = 0; i < 10; i++) {
            new Thread() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + "正在运行");
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        System.out.println(Thread.currentThread().getName() + "结束");
                        semaphore.release();
                    }
                }
            }.start();
        }
    }

输出：

Thread-5正在运行
Thread-5结束
Thread-0正在运行
Thread-0结束
Thread-3正在运行
Thread-3结束
Thread-8正在运行
Thread-8结束
Thread-6正在运行
Thread-6结束
Thread-2正在运行
Thread-2结束
Thread-7正在运行
Thread-7结束
Thread-1正在运行
Thread-1结束
Thread-4正在运行
Thread-4结束
Thread-9正在运行
Thread-9结束

其他组件

FutureTask

获得任务的返回值

BlockingQueue

阻塞队列，在线程池里有应用

乐观锁和悲观锁

悲观锁

对数据更新的冲突持保守态度，认为总会发生冲突。策略是在处理数据时加锁

乐观锁

乐观锁认为发生冲突的情况比较少，不加锁，而是在更新数据的时候检查是否发生了冲突。

乐观锁的两种实现

版本号机制

为数据库表增加版本号字段，每次更新数据版本号+1。在修改数据前获取版本号，提交修改时检查两次版本号是否一致，如不一致说明数据更新发生了冲突。

CAS

Compare And Swap
现值V、旧值A、新值B，当且仅当V==A，更新B到数据库
硬件实现的原子操作

乐观锁的缺点

ABA问题

CAS，V==A并不能说明V没有发生过改变

自旋锁开销大

CAS与synchronized使用场景

CAS适用读多写少，synchronized适用写多（冲突多）

synchronized和ReenTrantLock的区别

• 都是可重入
• synchronized由jvm实现，ReenTrantLock时jdk api
• ReenTrantLock高级功能：中断等待、公平锁、选择性通知
• 两者性能相差无几