基础概念

序言

好久没写文章了。最近在总结Java线程的一些知识（毕竟金九银十哈）。因此才有了这篇文章。网上关于Java线程的文章有很多。
当然也有很多使用RXJava框架的同学。由于个人工作原因，对于RxJava框架不是很了解。一直在接触Thread相关的知识。
用多了就总想总结巩固一下。因此有了这篇文章。

线程知识结构图

总结了一下多线程的相关知识，整理成了一个结构图。

线程知识结构图

线程基础

什么是线程：

线程是操作系统进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。

线程和进程的区别：

1. 线程是cpu调度的最小单位。
2. 进程是操作系统分配资源的最小单位。

什么是同步：

同步是指，程序控制不同线程间操作发生相对顺序的机制。（多个线程间，控制先后顺序的机制）

并发和并行的区别：

1. 并发：多个线程在同一个cpu上交替运行。由cpu分配不同的cpu时间片，从而实现多个线程同时运行的效果。
2. 并行：多个线程，在多个cpu上同时运行。

什么是切换上下文：

假设有线程A和线程B，同时在单核CPU上运行。cpu运行A时，会分配给相应的cpu时间片，在该时间片内从内存加载相关的线程A中执行内容的指令和数据。当时间片到了后，会把当前线程运行的数据和指令地址保存回内存中。然后从内存加载线程B相关的指令和数据
。这种任务从保存到加载的过程叫做线程的上下文切换。

Wait/Notify 等待/通知

1. 使线程进入等待状态。运行notify或者notifyAll方法进行唤醒。

    //锁的对象
    private Object obj=new Object();
    //判断条件(防止虚假唤醒)
    private volatile boolean isNotify=false;

    //在线程A中等待
    //1.锁对象
    //2.while一个判断条件（防止线程虚假唤醒）
    //3.对象.wait()
    public void wait() {
        synchronized (obj) {
            while (!isNotify) {
                obj.wait();//wait时会释放锁
            }
        }
    }

    //在线程B中唤醒
    //1.锁对象
    //2.改变判断条件
    //3.对象.notify() / 对象.notifyAll()
    //4.notify之后并不会立刻唤醒wait，必须等释放锁之后，线程A才能从wait中返回
    public void notify(){
        synchronized(obj){
            isNotify=true;
            obj.notify();//obj.notifyAll();
        }
    }

什么是死锁:

1. 两个线程同时等待对方释放锁。

    private Object A = new Object();
    private Object B = new Object();

    /**
     * 1. 线程thead_A获取锁A，线程thread_B获取锁B
     * 2. 线程thread_A等待thread_B释放锁B
     * 3. 线程thread_B等待thread_A释放锁A
     * 4. 两个线程互相等待，形成死锁
     */
    protected void deadLock () {
        Thread thead_A = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (A) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (B) {
                        //执行其他操作
                    }
                }
            }
        });
        Thread thead_B = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (B) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (A) {
                        //执行其他操作
                    }
                }
            }
        });
        thead_A.start();
        thead_B.start();
    }

如何避免死锁:

1. 同一线程中，只使用同一把锁。
2. 用JUC（java.util.concurrent 包中的锁ReentrantLock，CountDownLauch等）中的锁，设置超时时间。用来替代关键字synchronized。

后续:

基础知识大概就是这些。如有说的不对的请批评指正。后续还会更新文章。希望这篇文章可以帮助大家。可以的话记得收藏，点赞，投币.....  好像串台了。总之记得点赞哈 ~