JUC并发编程入门篇22_9_9

互联网萌新

已于 2022-09-11 17:10:46 修改

阅读量774

点赞数

分类专栏： java栏文章标签： java

于 2022-09-11 17:10:30 首次发布

本文链接：https://blog.csdn.net/weixin_53040516/article/details/126785783

版权

java栏专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、JUC简介

1.1进程与线程

进程： 计算机中程序的一次运行活动，是计算机系统进行资源分配及调度的基本单位。进程是线程的容器。程序是指令、数据以及组织形式的描述，进程是线程的容器。

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

1.2线程状态

线程的5中状态：
1.初始状态(NEW)： 新线程创建。
2.可运行状态(RUNNABLE)： 线程对象创建后，其它线程（如main线程）调用该对象的start（）方法。该状态线程位于可运行的线程池中，等待被线程调度机制选中，获取cpu使用权。
3.运行状态(RUNNING)： 可运行状态(runnable)的线程获得了cpu 时间片（timeslice），执行程序代码。
4.阻塞状态（BLOCKED） 线程放弃cpu使用权，也即让出了cpu timeslice，暂时停止运行，直到线程进入可运行（runnable）状态，才有机会获得cpu timeslice转到运行（running）状态。阻塞状态分为3种：

等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
其他阻塞：运行(running)的线程执行Thread.sleep(longms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
5.死亡状态(DEAD)： 线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。
1.2.1wait/sleep的区别
（1）sleep是Thread的静态方法，wait是Object的方法；
（2）sleep让线程阻塞不会释放锁，该方法也不需要占用锁。wait会释放锁，调用前提是线程有锁。

1.3 并发与并行

1.3.1串行模式

串行表示所有任务都一一按先后顺序进行，一次只能取得一个任务，并执行这个任务。

1.3.2并行模式

并行意味着可以同时取得多个任务，并同时去执行所取得的这些任务。并行的效率从代码层次上强依赖于多进程/多线程代码，从硬件角度上则依赖于多核 CPU。

1.3.3并发模式

并发(concurrent)指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行。但实际上，对于单核心 CPU 来说，同一时刻只能运行一个线程。所以，这里的"同时运行"表示的不是真的同一时刻有多个线程运行的现象，这是并行的概念，而是提供一种功能让用户看来多个程序同时运行起来了，但实际上这些程序中的进程不是一直霸占 CPU 的，而是执行一会停一会。
要解决大并发问题，通常是将大任务分解成多个小任务, 由于操作系统对进程的调度是随机的，所以切分成多个小任务后，可能会从任一小任务处执行。这可能会出现一些现象：

可能出现一个小任务执行了多次，还没开始下个任务的情况。这时一般会采用队列或类似的数据结构来存放各个小任务的成果
可能出现还没准备好第一步就执行第二步的可能。这时，一般采用多路复用或异步的方式，比如只有准备好产生了事件通知才执行某个任务。
可以多进程/多线程的方式并行执行这些小任务。也可以单进程/单线程执行这些小任务，这时很可能要配合多路复用才能达到较高的效率

1.3.3小结

并发： 同一时刻多个线程在访问同一个资源，多个线程对一个点
例子：春运抢票电商秒杀…
并行： 多项工作一起执行，之后再汇总
例子：泡方便面，电水壶烧水，一边撕调料倒入桶中

1.4 管程

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程。
管程可以看做线程中的锁。

1.5用户线程和守护线程

用户线程: 平时用到的普通线程,自定义线程
守护线程: 运行在后台,是一种特殊的线程,比如垃圾回收
当主线程结束后,用户线程还在运行,JVM 存活
如果没有用户线程,都是守护线程,JVM 结束

二、Lock接口

2.1.Synchronized

synchronized是java关键字，是同步锁，公平锁，它修饰的对象有以下几种：
1、修饰代码块，被修饰的代码块称为同步语句块，其作用的范围是{}中的代码，作用的对象是调用这个代码块的对象；
2、修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。
3、修饰静态方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4、修饰一个类，作用于整个类，两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

被synchronized修饰，获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完成，线程释放锁；
2）线程执行异常，JVM让线程自动释放锁；

2.2什么是Lock

Lock锁提供了比使用synchronized更广泛的锁操作。
区别：

Lock不是java内置的，synchronized是java语言的关键字，是内置的。Lock是一个接口类，通过这个类可以实现同步访问；
synchronized不需要用户去手动释放锁，而Lock则必须要用户去手动释放锁，否则会出现死锁现象

2.2.1Lock接口

public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}

unlock()通常放在finally块中执行，保证锁一定被释放。

2.2.2 newCondition

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式，Lock锁的newCondition()返回Condition对象，Condition类也可以实现等待/通知模式。
相比于notify（）的随机唤醒某个等待的线程，使用Condition类可以进行选择性通知，下面是Condition比较常用的两个方法：

await()会使当前线程等待，同时会释放锁，当其它线程调用signal()时，线程会重新获取锁并执行；
signal()用于唤醒一个等待的线程。
注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关的 Lock 锁，调用 await()后线程会释放这个锁，在 singal()调用后会从当前Condition 对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

2.3ReentrantLock

ReentrantLock是唯一实现Lock接口的类，意思是可重入锁，具体可自行百度^^。

2.4小结

1、Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；
2、 synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；
3、Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用synchronized 时，等待的线程会一直等待下去，不能够响应中断；
4、通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
5、Lock 可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要远远优于synchronized。

三线程间的通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析

3.1通信-lock方案

场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信,这里直接用lock方案了，synchronized同理。

class Share {
    private int number = 0;

    //创建Lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void incr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (number != 0) {
                condition.await();
            }
            //干活
            number++;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            //通知
            condition.signalAll();
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //-1
    public void decr() throws InterruptedException {
        lock.lock();
        try {
            while(number != 1) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+" :: "+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

3.2线程间定制化通信 lock

问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照此顺序循环 10 轮

class ShareResource {
    //定义标志位
    private int flag = 1;  // 1 AA     2 BB     3 CC

    //创建Lock锁
    private Lock lock = new ReentrantLock();

    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次，参数第几轮
    public void print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while(flag != 1) {
                //等待
                c1.await();
            }
            //干活
            for (int i = 1; i <=5; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //通知
            flag = 2; //修改标志位 2
            c2.signal(); //通知BB线程
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 2) {
                c2.await();
            }
            for (int i = 1; i <=10; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 3;
            //通知CC线程
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 3) {
                c3.await();
            }
            for (int i = 1; i <=15; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 1;
            //通知AA线程
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}