高并发JUC详解

最新推荐文章于 2024-05-01 05:44:36 发布

leslie ceng

最新推荐文章于 2024-05-01 05:44:36 发布

阅读量1.9k

点赞数 3

文章标签： java jvm 面试

本文链接：https://blog.csdn.net/weixin_48958124/article/details/126544691

版权

高并发

准备工作：导入maven依赖包

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.8</version>
</dependency>

第二步，将project里的modules的language level改为jdk8

第三步，将javaCompile改为jdk8

1.什么是JUC

JUC简称：Java util.concurrent 并发

java.util.concurrent.atomic 原子性

java.util.concurrent.locks

业务：普通的线程代码 Thread

Runnable：没有返回值，效率相比于Callable相对较低

2.线程和进程

一个进程可以有多个线程，且至少包含一个。

java默认线程:main ,gc线程，三种开启线程方式：Thread，Runnable，Callable

java是不能真正的开启多线程，源码中是调用了本地native方法，底层C++，java是作用在虚拟机上的，无法直接操作硬件

2.1 并发和并行

并发：多线程操作同一个资源，cpu单核模拟多个线程

并行：多个人一起行走，cpu多核，多个线程可以同时执行，线程池

//获取cpu的核数
//cpu密集型，IO密集型
Runtime.getRuntime().availableProcessors();

并发的本质：充分利用cpu的资源

线程状态：

public enum State {
   
   //线程新生
    NEW,
   //运行
    RUNNABLE,
   //阻塞
    BLOCKED,
   //等待，死等
    WAITING,
   //超时等待
    TIMED_WAITING,
    //终止
    TERMINATED;
}

wait/sleep区别：

1.来自不同的类，wait来自obj类，sleep来自Thread类

2.wait会释放锁，sleep不会释放锁

3.使用范围不同：wait必须在同步代码块中，sleep无限制

3.Lock锁

Synchronized同步锁，关键字，本质：排队，锁

并发：多线程操作同一个资源类，把资源类丢进线程里，Runnable函数式接口可以new被成为匿名内部类，但繁琐，所以用lambda表达式来代替()->{}

new Thread(()->{
   },"name").start;

Interface Lock：

实现类：ReentrantLock可重入锁，ReentrantReadWriteLock.ReadLock读锁，eentrantReadWriteLock.WriteLock写锁
在这里插入图片描述

公平锁：十分公平，先来后到

非公平锁：十分不公平，可以插队（默认）

Lock：手动加锁，手动释放锁

Synchronized和Lock区别

Synchronized是Java内置关键字，而Lock是Java类
Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
Synchronized会自动释放锁，Lock必须要手动释放锁。如果不释放锁，会造成死锁！
Synchronized 线程1(获得锁，阻塞)，线程2(等待，傻傻地等)；Lock就不一定会等下去
Synchronized可重入锁，不可以中断的，非公平；Lock,可重入锁，可以判断锁，非公平(可以自己手动设置)
Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码！

锁是什么，如何判断锁的是谁！

4.生产者和消费者问题

步骤：判断等待，业务，通知

面试：单例模式，排序算法，生产者消费者，死锁

线程也可以唤醒，而不会通知，中断或者超时即所谓的虚假唤醒，等待应该总是出现在while循环中

JUC版的生产者和消费者问题

在这里插入图片描述

Lock替代synchronized方法和语句的使用，Condition取代了对象

Condition方法：

condition.await();
condition.signalAll();

package com.liang.lesson1;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
生产者和消费者问题
用JUC lock()实现
 */
public class PC1 {
   
    public static void main(String[] args) {
   
        Product1 product1 = new Product1();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                product1.add();
            }
        },"生产者A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                product1.delete();
            }

        },"消费者A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                product1.add();
            }
        },"生产者B").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                product1.delete();
            }
        },"消费者B").start();
    }
}
// 判断等待,业务,通知
class Product1{
   
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public  void add(){
   
        try {
   
            lock.lock();
            while (number!=0){
   
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
    public  void delete(){
   
        try {
   
            lock.lock();
            while (number==0){
   
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        } finally {
   
            lock.unlock();
        }
    }
}

Condition精准通知和唤醒线程

package com.liang.lesson1;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
@SuppressWarnings("all")
/*
Condition实现精准通知唤醒
A执行完调用B,B执行完调用C,C执行完调用A.实现依次执行.
 */
public class PC2 {
   
    public static void main(String[] args) {
   
        Data data = new Data();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printA();
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printB();
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                data.printC();
            }
        },"C").start();
    }
}
class Data {
   
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int num = 1;
    public void printA() {
   
        lock.lock();
        try {
   
            if (num != 1) {
   
                condition1.await();
            }
            num = 2;
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAAAAAAAAAAAA");
            condition2.signal();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();
        }
    }
    public void printB(){
   
        lock.lock();
        try {
   
            if (num != 2) {
   
                condition2.await();
            }
            num = 3;
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBBBBBBBB");
            condition3.signal();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();
        }
    }
    public void printC(){
   
        lock.lock();
        try {
   
            if (num != 3) {
   
                condition3.await();
            }
            num = 1;
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCCCCCCCCC");
            condition1.signal();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }finally {
   
            lock.unlock();
        }
    }

}

5.八锁现象

zpackage com.liang.lesson1;

import java.util.concurrent.TimeUnit;
@SuppressWarnings("all")
/*
八锁现象
1.标准情况下，两个线程操作同一对象的1.标准情况下sychronized方法，谁先调用这个方法，谁就先拿到调用这个方法的对象的这把锁
2.当两个线程同时操作同一个对象时，没加同步锁的方法不受锁的影响，按照代码的实际情况输出
3.当两个线程同时操作两个不同的对象时，这两个线程互不受影响，按照代码实际情况输出
4.当sychronize修饰的时静态static方法时，锁的对象是class对象，class对象有且只有一个，即使是两个线程操作不同的对象，谁先调用sychronized方法，谁就先获得这把锁
5.一个静态同步方法，一个普通同步方法，一个对象，两个线程分别调用不同的方法，这时两个线程锁的是不同的对象，互不影响
6.同理两个对象也是一样的
总结：当调用sychronized所修饰的方法时，调用这个方法的对象就先属于谁(即谁拿到这个对象的锁),所以分析两个线程先后顺序时，要看这两个线程
是否是同一把锁，如果是的话，谁先获得锁，谁就先执行。如果是不同的锁，就是按照代码实际情况处理
 */
public class eightLock {
   
    public static void main(String[] args) throws InterruptedException {
   
        Phone phone = new Phone();
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                phone.call();
            }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
   
            for (int i = 0; i < 10; i++) {
   
                phone.sendMessage();
            }
        },"B").start();
    }
}

class Phone{
   
    public synchronized void call(){
   
        System.out.println("打电话");
    }
    public synchronized void sendMessage(){
   
        System.out.println("发短信");
    }
}

6.集合类不安全

并发下的ArrayList不安全，会报错：java.util.ConcurrentModificationException,解决方法：

1.Vector objects = new Vector<>();
2.Collections.synchronizedList(new ArrayList<>());工具类变成安全的
3.JUC下的解决方案: List list1 = new CopyOnWriteArrayList<>();
写入时复制，计算机程序设计的一种优化策略，在写入的时候避免覆盖，造成数据问题，读写分离
底层就是新复制了一个数组再插入进去，效率高，因为没有用synchronized，用的lock

package com.liang.lesson2;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class Demo01 {
   
    public static void main(String[] args) {
   
        // 并发下,ArrayList是不安全的.
        // 解决方法：
        //1.Vector<String> vector = new Vector<>();
        //2. List<String> list = Collections.synchronizedList(new ArrayList<>());
        //3.CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
   
            new Thread(()->{
   
               list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.