Java多线程四：Java必学并发编程基础

全栈学习笔记

发布于 2023-09-09 08:42:00

1960

发布于 2023-09-09 08:42:00

走近Java并发编程的世界

Java并发编程是指在Java程序中使用多线程技术，以实现多个线程同时执行的编程方式。这是一个非常重要的主题，因为它可以使程序更加高效，能够更好地应对需要同时执行多个任务的情况。除此之外，Java并发编程还可以提高程序的可伸缩性和可扩展性，从而使程序更加健壮。要实现这些，需要深入了解Java中的线程模型，包括线程的状态、同步机制、锁、内存模型等。在学习Java并发编程时，需要认真学习这些概念，并进行大量的实践，以便更好地理解和掌握这个主题。

在Java中，线程是一种轻量级的进程，它可以与其他线程共享内存和CPU时间，并且可以在同一时间内运行多个线程。这意味着可以在程序中同时执行多个任务，从而提高程序的效率和性能。然而，多线程编程也存在一些挑战，例如线程安全、死锁、竞争条件等。为了避免这些问题，需要采用适当的同步机制和锁，以确保线程之间的正确协作。

总之，Java并发编程是一项非常重要的技能，它可以帮助程序员构建更加高效、可伸缩和健壮的程序。要成为一名优秀的Java开发人员，需要深入了解Java并发编程，并进行大量的练习和实践。

并发编程的基础

在理解并发编程之前，需要先理解程序、进程和线程的概念。

程序：是一组指令的集合，用于完成特定的任务。
进程：是一个正在执行的程序实例，它有自己的内存空间和系统资源。
线程：是进程中的一个执行单元，一个进程可以包含多个线程。

在并发编程中，有几个重要的概念需要理解。

串行：指的是任务按照顺序依次执行，每个任务必须等待前一个任务完成后才能开始执行。
并行：指的是多个任务同时执行，每个任务都有自己的执行线程，可以同时使用CPU资源。
并发：指的是多个任务在同一时间段内执行，它们可能共享同一个线程或者交替使用CPU资源。
同步：指的是任务按照顺序依次执行，每个任务必须等待前一个任务完成后才能开始执行。
异步：指的是任务按照顺序不依次执行，每个任务可以在任意时刻开始执行，不需要等待前一个任务完成。

并发编程的三大特性

原子性

原子性是指一个操作是不可中断的，要么全部执行成功，要么全部执行失败，不存在执行一半的情况。在Java中，可以使用synchronized关键字和Lock接口来保证方法和代码块的原子性。

原子性在并发编程中也是非常重要的。由于多个线程同时访问共享资源时可能会出现数据竞争的问题，因此保证操作的原子性可以避免这种情况的发生。除了使用synchronized关键字和Lock接口之外，还可以使用原子类来实现原子操作。例如，Java提供了AtomicInteger、AtomicLong等类来支持原子操作。

以下是一个原子性的例子：

public class AtomicityDemo {
    private static int count = 0;

    public static synchronized void increase() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("count: " + count);
    }
}

上面的代码中，使用synchronized关键字保证了increase()方法的原子性。最终输出的结果应为20000。

除了使用synchronized关键字以外，还可以使用Lock接口来保证方法和代码块的原子性。使用Lock接口的方式和使用synchronized关键字的方式类似，只需要在代码块或方法中先调用lock()方法获取锁，然后在try-finally语句块中执行需要保证原子性的操作，最后调用unlock()方法释放锁。这样就可以保证同一时间只有一个线程可以执行这段代码，从而保证了原子性。

可见性

可见性是指一个线程对共享变量的修改能够被其他线程及时地看到。这种及时的看到保证了程序的正确性。在Java中，可以使用volatile关键字来保证可见性。volatile关键字不仅保证了可见性，还保证了有序性。有序性指的是在进行指令重排时，不会改变volatile变量的顺序。这保证了程序的正确性，同时也避免了出现与预期不符的结果。

以下是一个可见性的例子：

public class VisibilityDemo {
    private static volatile boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            while (flag) {
                // do something
            }
        });
        thread1.start();
        Thread.sleep(1000);
        flag = false;
        thread1.join();
    }
}

上面的代码中，使用volatile关键字保证了flag变量的可见性。线程1会一直执行，直到flag被修改为false。如果不使用volatile关键字，则线程1永远不会退出。

有序性

在 Java 中，有序性是指程序执行的顺序按照代码的先后顺序执行。如果程序的执行顺序不正确，就可能会导致程序出现错误。比如，如果一个线程先执行了 A 操作，再执行 B 操作，而另一个线程先执行了 B 操作，再执行 A 操作，就有可能会导致数据出现错误（涉及到指令重排问题）。

Java 提供了多种机制来保证有序性，其中最常用的是 synchronized 关键字、Lock 接口和 volatile 关键字。synchronized 关键字可以保证同一时刻只有一个线程执行代码块，从而避免了多线程之间的竞争。Lock 接口提供了更加灵活的锁机制，可以实现更加细粒度的同步控制。volatile 关键字可以保证变量的可见性和有序性，从而避免了多线程之间的竞争。

在 Java 中，由于有指令重排的存在，程序的执行顺序可能会与代码的顺序不一致，这就会导致程序出现错误。为了解决这个问题，Java 引入了 volatile 关键字。volatile 关键字可以禁止指令重排，从而保证程序的正确执行顺序。在 Java 中，如果一个变量被声明为 volatile，那么在对该变量进行读写操作时，都会直接从内存中读取和写入，而不是从 CPU 缓存中读取和写入。这样就能够保证多个线程之间对该变量的读写操作是有序的，避免了出现与预期不符的结果。

要保证程序的正确执行顺序，可以使用 synchronized 关键字、Lock 接口和 volatile 关键字。针对具体的需求，可以选择不同的机制来保证程序的正确性。

以下是一个验证volatile有序性的例子：

public class VolatileOrderingDemo {
    private static volatile String context = null;
    private static volatile boolean inited = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            context = "hello, world"; // 语句1
            inited = true; // 语句2
        });
        Thread thread2 = new Thread(() -> {
            while (!inited) {
                try {
                    Thread.sleep(100); // 等待语句2执行完成
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            doSomethingWithConfig(context); // 语句3
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

在这个例子中，线程1先执行语句1，然后执行语句2；线程2不断循环，直到inited变量被线程1修改为true。当inited变量为true时，线程2会执行语句3，打印出context变量的值。由于context变量被声明为volatile，因此它的值会被及时地更新到主内存中，从而保证了可见性和有序性。因此，在这个例子中，语句1和语句2的执行顺序不会被重新排序，语句3也不会在语句2之前执行。如果没有使用volatile关键字，那么就可能会出现语句3在语句2之前执行的情况，从而导致程序出现错误。

简单总结一下

特性	volatile关键字	synchronized关键字	Lock接口	Atomic变量
原子性	无法保障	可以保障	可以保障	可以保障
可见性	可以保障	可以保障	可以保障	可以保障
有序性	一定程度保障	可以保障	可以保障	无法保障