java后端知识点梳理——多线程与高并发

进程与线程

进程是一个“执行中的程序”，是系统进行资源分配和调度的一个独立单位

线程是进程的一个实体，一个进程中一般拥有多个线程。

线程和进程的区别

• 进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元。
• 进程有独立的地址空间，相互不影响，线程只是进程的不同执行路径
• 线程没有独立的地址空间，多进程的程序比多线程的程序健壮
• 进程的切换比线程的切换开销大，所以线程上下文的切换比进程上下文切换要快很多。

为什么线程上下文切换比进程上下文切换快？

• 进程切换时，涉及到当前进程的CPU环境的保存和新被调度运行进程的CPU环境的设置
• 线程切换时，仅需要保存和设置少量的寄存器内容，不涉及存储管理方面的操作

线程没有独立的地址空间，哪有独属于自己的资源吗？

有，通过ThreadLocal可以存储线程的特有对象，也就是属于当前线程的资源。

进程的通信方式

通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等

进程之间常见的通信方式一般有：

• 通过使用套接字Socket来实现不同机器间的进程通信
• 通过映射一段可以被多个进程访问的共享内存来进行通信
• 通过写进程和读进程利用管道进行通信

线程的通信方式

• volatile
• 使用Object类的 wait() 和 notify() 方法
• CountDownLatch 方式实现
• join + synchronize/Reentrantlock

volatile

volatile有两大特性，一是可见性，二是有序性，禁止指令重排序，其中可见性就是可以让线程之间进行通信。

volatile语义保证线程可见性有两个原则保证

• 所有volatile修饰的变量一旦被某个线程更改，必须立即刷新到主内存
• 所有volatile修饰的变量在使用之前必须重新读取主内存的值

volatile保证可见性原理图

工作内存2能够感知到工作内存1更新a值是靠的总线，工作内存1在将值刷新的主内存时必须经过总线，总线就能告知其他线程有值被改变，那么其他线程就会主动读取主内存的值来更新。

public class VolatileDemo {

    private static volatile boolean flag = true;

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    if (flag){
                        System.out.println("trun on");
                        flag = false;
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    if (!flag){
                        System.out.println("trun off");
                        flag = true;
                    }
                }
            }
        }).start();
    }
}
复制代码

如上代码所示，输出结果会在 trun on 和 trun off 之间切换，这是因为经过了总线，线程之间相互通信，知道flag值的改变。如果去掉了volatile，在线程切换一定次数后就会发现感知不到flag值的变化了。

wait和notify方法

wait和notify方法来实现等待/通知机制.在一个线程内调用该线程锁对象的wait方法，线程将进入等待队列进行等待直到被通知或者被唤醒，完成线程之间的通信交互。

CountDownLatch

写两个线程，线程1添加10个元素到容器中， 线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束

public class WithoutVolatile1 {
    private volatile List list=Collections.synchronizedList (new LinkedList <> ());
    public  void add(Object i){
        list.add (i);
    }
    public  int size(){
        return list.size ();
    }

    public static void main(String[] args) {
        WithoutVolatile1 w=new WithoutVolatile1();
        //为什么要创建两个门闩呢？
        //假如你用一个CountDownLatch 的话会导致线程二在执行的同时出现了CPU的上下文切换，导致数据的不一致，可以多试几次就会发现问题
        CountDownLatch countDownLatch = new CountDownLatch (1);
        CountDownLatch latch = new CountDownLatch (1);
        Thread thread = new Thread (() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    if (w.size ( ) == 5) {
                        countDownLatch.countDown ( );
                        latch.await ();
                    }
                    w.add (i);
                    System.out.println("添加 " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace ( );
            }
        });
        Thread thread1 = new Thread (() -> {
            try {
                if(w.size ()!=5){
                    countDownLatch.await ( );
                }
                System.out.println ("监听到了，结束。。。。");
                latch.countDown ();
            } catch (InterruptedException e) {
                e.printStackTrace ( );
            }
        });
        thread.start ();
        thread1.start ();

    }
}
复制代码

线程的状态有哪些？

线程的状态包括 新建状态，运行状态，阻塞等待状态和消亡状态。其中阻塞等待状态又分为BLOCKED, WAITING和TIMED_WAITING状态。

new(新建)->ready(可运行)->running(运行中)->blocked(阻塞状态)->waiting(等待状态)->time_waiting(超时等待)->terminated(终止状态)