1501 - JUC高并发

最新推荐文章于 2024-09-01 21:30:44 发布

半自定义大剑仙

最新推荐文章于 2024-09-01 21:30:44 发布

阅读量855

点赞数 11

分类专栏： Java基础学习文章标签： jvm java

本文链接：https://blog.csdn.net/2301_76354366/article/details/139475603

版权

Java基础学习专栏收录该内容

24 篇文章 0 订阅

订阅专栏

须知少许凌云志，曾许人间第一流

看的是尚硅谷的视频做的学习总结，感恩老师，下面是视频的地址

传送门https://www.bilibili.com/video/BV1Kw411Z7dF

0.思维导图

1.JUC简介

1.1 什么是JUC

JUC， java.util.concurrent工具包的简称，一个处理线程的工具包。

1.2 进程和线程的概念

1.2.1 进程与线程

进程

指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程是资源分配的最小单位。

线程

系统分配处理器时间资源的基本单元；进程之内独立执行的一个单元执行流；线程是程序执行的最小单位。

一个进程包含多个线程。

1.2.2 线程的状态

查看jdk源码

1.2.3 wait 和 sleep

区别

sleep是Thread的静态方法；wait是Object的方法，任何对象实例都能调用。
sleep不会释放锁，它也不需要占用锁；wait会释放锁。（wait会释放锁去睡觉，sleep会抓住锁去睡觉，在哪里谁就会在哪里醒）
它们都可以被interrupt方法中断。

1.2.4 并发和并行

并发

同一时间间隔内多个线程交替执行，实际上是宏观上并行，微观上串行。（春运抢票，电商秒杀，抢同一个资源）

并行

同一时刻多个线程正在执行，多核并行。（一边看书，一边听音乐）

1.2.5 管程

叫 Monitor 监视器，就是锁。

是一种同步机制，保证同一个时间，只有一个线程访问被保护的数据或者代码。

1.2.6 用户线程和守护线程

用户线程

自定义的线程，不随主线程的结束而结束。主线程结束了，用户线程还会运行，jvm还是存活状态。

守护线程

随着主线程的结束而结束，如垃圾回收线程。主线程结束，jvm结束。

2.Lock接口

2.1 Synchronized

2.1.1 Synchronized作用范围

synchronized是Java的关键字，是一种同步锁。

synchronized的作用范围可以根据使用方式的不同而有所区别，主要有以下几种情况：

同步方法（实例方法）

public class SynchronizedExample {
    public synchronized void syncMethod() {
        // 同步代码块
    }
}

当synchronized修饰一个实例方法时，它作用于整个方法体。当一个线程进入一个对象的同步方法时，其他线程在该对象上调用同步方法时会被阻塞，直到第一个线程退出该方法。这种同步方式是基于对象的，也就是说，不同的对象实例的同步方法是互不干扰的。

同步静态方法

public class SynchronizedExample {
    public static synchronized void syncStaticMethod() {
        // 同步代码块
    }
}

当synchronized修饰一个静态方法时，它作用于整个静态方法体。由于静态方法是属于类的，而不是类的实例，因此这种同步是基于类的。当一个线程进入一个类的同步静态方法时，其他线程在该类上调用同步静态方法时会被阻塞。

同步代码块

public class SynchronizedExample {
    private final Object lock = new Object();

    public void someMethod() {
        synchronized (lock) {
            // 同步代码块
        }
    }
}

synchronized也可以用来修饰一个代码块，此时需要指定一个对象作为锁对象。当线程进入同步代码块时，它会获取指定对象的锁，如果其他线程已经持有该对象的锁，则进入阻塞状态。这种同步方式允许更细粒度的控制，只同步需要同步的代码部分。

2.1.2 多线程编程步骤

第一步：创建资源类，在资源类创建属性和操作方法。

第二步：创建多个线程，去调用资源类的操作方法。

2.1.3 Synchronized实现买票示例

需求：3个售票员卖一百张门票。

分析：资源是一百张门票，操作方法是买票，创建多个线程是3个售货员。

代码示例

// 第一步：定义资源类
class Ticket {
    // 第二步：定义资源
    public int number = 100;

    // 第三步：定义操作方法
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + (100 - number + 1) + "张票，剩余" + --number + "张票");
        }
    }
}

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // 使用匿名内部类创建线程
        Runnable runnable = () -> {
            for (int i = 0; i < 150; i++) {
                ticket.sale();
            }
        };

        // 创建多个线程进行卖票
        new Thread(runnable,"售票员1").start();
        new Thread(runnable,"售票员2").start();
        new Thread(runnable,"售票员3").start();
    }
}

输出结果

2.2 Lock

2.2.1 Lock接口的介绍

Lock 实现提供比使用 synchronized 方法和语句可以获得的更广泛的锁定操作。

2.2.2 使用Lock实现卖票例子

// 第一步：定义资源类
class Ticket {
    // 第二步：定义资源
    public int number = 100;

    // 创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    // 第三步：定义操作方法
    public synchronized void sale() {
        // 手动上锁
        lock.lock();
        try{
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第" + (100 - number + 1) + "张票，剩余" + --number + "张票");
            }
        }finally {
            // 手动解锁
            lock.unlock();
        }
    }
}

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // 使用匿名内部类创建线程
        Runnable runnable = () -> {
            for (int i = 0; i < 150; i++) {
                ticket.sale();
            }
        };

        // 创建多个线程进行卖票
        new Thread(runnable,"售票员1").start();
        new Thread(runnable,"售票员2").start();
        new Thread(runnable,"售票员3").start();
    }
}

2.2.3 synchronized和Lock两者差异

synchronized是java内置关键字。Lock不是内置，可以实现同步访问且比 synchronized中的方法更加丰富。
synchronized自动释放锁，而lock需手动释放锁（不解锁会出现死锁，需要在 finally 块中释放锁）。
Lock 可以让等待锁的线程响应中断，而等待synchronized锁的线程不能响应中断，会一直等待。
通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
Lock 可以提高多个线程进行读操作的效率（当多个线程竞争的时候，Lock 性能远远好于synchronized）。

2.2.4 创建线程的四种方式

继承Thread类
实现Runnable接口
使用Callable接口
使用线程池

3.线程间通信

3.1 多线程编程步骤

第一步：创建资源类，在资源类创建属性和操作方法。

第二步：在资源类操作方法，判断、干活、通知。

第三步：创建多个线程，去调用资源类的操作方法。

第四步：防止虚假唤醒。

3.2 synchronized 实现线程通信案例

关键字 synchronized 与 wait()/notify() 这两个方法一起使用可以实现等待/通知模式。

代码示例

// 第一步：创建资源类，定义属性和操作方法
class Share {
    private int number = 0;

    // +1的方法
    public synchronized void incr() throws InterruptedException {
        // 第二步：判断
        if (number != 0) {
           this.wait();
        }
        // 干活
        number++;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        // 通知其他线程
        this.notifyAll();
    }

    // -1的方法
    public synchronized void decr() throws InterruptedException {
        // 判断
        if (number != 1) {
            this.wait();
        }
        // 干活
        number--;
        System.out.println(Thread.currentThread().getName() + ":" + number);
        // 通知其他线程
        this.notifyAll();
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 第三步：创建多个线程，调用资源类中的操作方法
        Share share = new Share();

        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "生产").start();

        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "消费").start();

    }

}

3.3 虚假唤醒问题（if改while）

当多个线程都处于等待集合中，一旦收到通知，可以直接操作而不再判断，这叫做虚假唤醒问题。将this.wait()放在while循环中可以解决该问题。

代码示例

class Share {
    int number = 0;

    public synchronized void incr() throws InterruptedException {
        //判断
        if (number != 0) {
            this.wait();//这里会释放锁
        }
        //执行
        number++;
        System.out.print(Thread.currentThread().getName() + " : " + number + "-->");
        // 通知
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        //判断
        if (number != 1) {
            this.wait();
        }
        //执行
        number--;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        //通知
        this.notifyAll();
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "D").start();
    }
}

输出结果

原因

由于 wait() 方法使线程在哪里睡就在哪里醒，B和D在wait后被唤醒，执行操作时不会再通过 if 判断，从而导致出现异常结果。
为了保证线程“醒了”之后再次判断，需要将wait() 方法放入while循环中。

class Share {
    int number = 0;

    public synchronized void incr() throws InterruptedException {
        //判断
        while (number != 0) {
            this.wait();
        }
        //执行
        number++;
        System.out.print(Thread.currentThread().getName() + " : " + number + "-->");
        // 通知
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        //判断
        while (number != 1) {
            this.wait();
        }
        //执行
        number--;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        //通知
        this.notifyAll();
    }
}

3.4 Lock实现线程间通信案例

在 Lock 接口中，有一个 newCondition() 方法，返回一个新 Condition 绑定到该实例 Lock 实例。

Condition 类中有 await() 和 signalAll() 等方法，和 synchronized 实现案例中的 wait() 和 notifyAll() 方法相同。

代码示例

class Share {
    private int number = 0;
    //创建Lock
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void incr() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                condition.await();
            }
            number++;
            System.out.print(Thread.currentThread().getName() + " : " + number + "-->");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    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();
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "D").start();
    }
}

4.线程间定制化通信

4.1 Condition 类选择性通知

案例： 启动三个线程，按照如下要求执行，AA打印5此，BB打印10次，CC打印15次，一共进行10轮
具体思路： 每个线程添加一个标志位，是该标志位则执行操作，并且修改为下一个标志位，通知下一个标志位的线程。

代码示例

class ShareResource {
    // 标志位 1:AA 2:BB 3:CC
    private int flag = 1;
    private ReentrantLock lock = new ReentrantLock();
    // 创建三个Condition对象，实现定向唤醒
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();

    public void print5(int loop) throws InterruptedException {
        lock.lock();
        try {
            while (flag != 1) {
                c1.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", loop=" + loop);
            }
            flag = 2;
            c2.signal();
        } finally {
            lock.unlock();
        }
    }

    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while (flag != 2) {
                c2.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", loop=" + loop);
            }
            flag = 3;
            c3.signal();
        } finally {
            lock.unlock();
        }
    }

    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while (flag != 3) {
                c3.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + " :: " + i + ", loop=" + loop);
            }
            flag = 1;
            c1.signal();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "BB").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "CC").start();
    }
}

上面的代码采用单标志法，设置一个公用整型变量flag，用于指示被允许进入临界区的进程编号。

若 flag =1，则允许 AA 进程进入临界区；

若 flag =2，则允许 BB 进程进入临界区；

若 flag =3，则允许 CC 进程进入临界区。

该算法可确保每次只允许一个进程进入临界区。但两个进程必须交替进入临界区，若某个进程不再进入临界区，则另一个进程也无法进入临界区。在线程的run()方法调用中设置不同的loop次数，在后期会有部分线程不能访问 Share 资源了，违背了"空闲让进"原则，让资源利用不充分。

4.2 进程/线程同步四个原则

空闲让进：临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区。
忙则等待：当已经有进程进入临界区的时候，其他试图进入临界区的进程必须等待。
有限等待：对请求访问的进程，应保证能在有限时间内进入临界区。
让权等待：当进程不能进入临界区的时候，应立即释放处理机，防止进程忙等待。

5.集合的线程安全

集合线程不安全，简单来说就是底层的方法没有使用同步安全锁。

5.1 ArrayList 不安全

jdk源码

没有使用synchronized关键字，所以在多线程并发时，会出现线程安全问题。

代码示例

public class ThreadDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

运行报错

5.2 解决方案 Vector

jdk源码

Vector类中的方法加了synchronized关键字，因此可以保证线程安全。

代码改造

public class ThreadDemo {
    public static void main(String[] args) {
        List<String> list = new Vector<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

运行结果

5.3 解决方案 synchronizedList(List list)

Collections 接口中的 synchronizedList(List list) 方法，可以将传入的 List列表对象转为同步（线程安全的）列表并返回。

语法

List<String> list = Collections.synchronizedList(new ArrayList<>());

jdk源码

代码示例

public class ThreadDemo {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

5.4 解决方案 CopyOnWriteArrayList

语法

List<String> list = new CopyOnWriteArrayList<>();

CopyOnWriteArrayList 采用读写分离的思想，读操作不加锁，写操作加锁。（redis也使用）

读的时候并发读取旧数据（多个线程操作）
写的时候独立，先复制一份比旧数据长 1 的数据出来，在最后添加数据，旧新合并，完成写操作，之后就可以读所有数据（每次加新内容都写到新区域，合并之前旧区域，读取新区域添加的内容）

半自定义大剑仙

关注

11
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
1501 - JUC高并发

JUC简介；Lock接口；线程间通信；线程间定制化通信；集合的线程安全
复制链接

扫一扫

专栏目录