Java并发编程 - 第一章并发编程面临的挑战

最新推荐文章于 2024-04-30 11:03:01 发布

码渔

最新推荐文章于 2024-04-30 11:03:01 发布

阅读量1.3w

点赞数

分类专栏： Java并发编程文章标签：数据库多线程 java 分布式并发编程

本文链接：https://blog.csdn.net/weixin_41105242/article/details/108091936

版权

Java并发编程专栏收录该内容

13 篇文章 3 订阅

订阅专栏

前言：

并发编程的目的是为了让程序运行得更快，但是，并不是启动更多的线程就能让程序最大限度地并发执行。在进行并发编程时，如果希望通过多线程执行任务让程序运行得更快，会面临非常多的挑战，比如上下文切换的问题、死锁的问题，以及受限于硬件和软件的资源限制问题，本章会介绍几种并发编程的挑战以及解决方案。

一、上下文切换

即使是单核处理器也支持多线程执行代码，CPU 通过给每个线程分配 CPU 时间片来实现这个机制。时间片是 CPU 分配给各个线程的时间，因为时间片非常短，所以 CPU 通过不停地切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒（ms）。

CPU 通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。

上下文切换会影响多线程的执行速度。

二、如何减少上下文切换

减少上下文切换的方法有无锁并发编程、CAS 算法、使用最少线程和使用协程。

无锁并发编程：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的 ID 按照 Hash 算法取模分段，不同的线程处理不同段的数据。
CAS算法：Java 的 Atomic 包使用 CAS 算法来更新数据，而不需要加锁。
使用最少线程：避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态。
协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。

三、死锁

这段代码会引起死锁，使线程 t1 和线程 t2 互相等待对方释放锁。

public class DeadLockDemo {
    
    private static final String A = "A";
    private static final String B = "B";

    public static void main(String[] args) {
        new DeadLockDemo().deadLock();
    }

    private void deadLock() {
        Thread t1 = new Thread(() -> {
            synchronized (A) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (B) {
                    System.out.println("1");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (B) {
                synchronized (A) {
                    System.out.println("2");
                }
            }
        });
        t1.start();
        t2.start();
    }
    
}

一旦出现死锁，业务是可感知的，因为不能继续提供服务了，那么只能通过 dump 线程查看到底是哪个线程出现了问题，以下线程信息告诉我们是 DeadLockDemo 类的第 26 行和第 19 行引起的死锁。

"Thread-1" #9 prio=5 os_prio=0 tid=0x00007f704c20d800 nid=0x3db3 waiting for monitor entry [0x00007f7035e32000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at DeadLockDemo.lambda$deadLock$1(DeadLockDemo.java:26)
        - waiting to lock <0x00000000ec460c68> (a java.lang.String)
        - locked <0x00000000ec460c98> (a java.lang.String)
        at DeadLockDemo$$Lambda$2/303563356.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
        - None

"Thread-0" #8 prio=5 os_prio=0 tid=0x00007f704c20b800 nid=0x3db2 waiting for monitor entry [0x00007f703c1f0000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at DeadLockDemo.lambda$deadLock$0(DeadLockDemo.java:19)
        - waiting to lock <0x00000000ec460c98> (a java.lang.String)
        - locked <0x00000000ec460c68> (a java.lang.String)
        at DeadLockDemo$$Lambda$1/471910020.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

现在我们介绍避免死锁的几个常见方法。 ·避免一个线程同时获取多个锁。