Java多线程介绍

为什么需要多线程

假设我们有一个程序，它的结构是这个样子

1. 一个非常耗时的IO操作
2. 一个简单的运算

如果你了解CPU ，内存， 硬盘 之间速度巨大的差异的话，你马上就会反应过来，在第一个任务完成之前，CPU会被挂起来，这对于计算机的资源是一种巨大的浪费。
为了提高CPU和IO设备的综合利用率，我们引入了多线程程序，例如，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样一来，计算机资源的利用率就会大大提高。尤其是现在计算机都拥有多个CPU核心，假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。

使用多线程会带来哪些问题

会带来很多问题，比如，当我们有多个线程同时读写共享变量，会出现数据不一致的问题。

public class Main {
    public static void main(String[] args) throws Exception {
        var add = new addThread();
        var dec = new decThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static int count = 0;
}

class addThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count += 1; }
    }
}

class decThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count -= 1; }
    }
}

上面这个程序很好理解，但是结果却和理想中不一样，这就是多线程所带来的问题，当有多个线程同时对某个变量执行操作，由于这个操作不是原子操作（即整个操作要么全部完成，要么就不要开始），所以往往最后的结果无法预料。

对于这个问题，可以使用加锁的方式使操作变为原子操作，在Java中，可以使用synchronized 关键字对一个对象加锁。例如

ublic class Main {
    public static void main(String[] args) throws Exception {
        var add = new addThread();
        var dec = new decThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static final Object lock = new Object();
    public static int count = 0;
}

class addThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count += 1;
            }
        }
    }
}

class decThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count -= 1;
            }
        }
    }
}

其中

            synchronized(Counter.lock) {
                Counter.count += 1;
            }

表示以lock作为锁，只有获得锁，才能进入代码块执行，代码块中的语句执行完后，锁会被自动释放，这样就解决了多线程同步访问共享变量的正确性问题。但是使用synchronized 同时也会使得性能下降，因为它无法并发的执行。

成功的解决上个问题后，加锁的方式也会带来新的问题，那就是 死锁 的问题，看下面这个例子

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockB) { // 获得lockB的锁
        this.another -= m;
        synchronized(lockA) { // 获得lockA的锁
            this.value -= m;
        } // 释放lockA的锁
    } // 释放lockB的锁
}

在这个代码示例中，如果有两个线程1和2分别执行add()， dec() 方法，就会发生如下情况：

线程1开始执行add()方法，并获得lockA锁
线程2开始执行dec()方法，并获得lockB锁

然后

线程1尝试获取lockB锁，发现lockB锁被占用，于是等待lockB锁被释放
线程2尝试获取lockA锁，发现lockA锁被占用，于是等待lockA锁被释放

然后就是无穷的等待，程序陷入死锁状态。

小结

使用多线程是为了提高计算机的资源利用率和程序执行的性能
多线程不总是能提高程序性能，反而会引入单线程程序中不会碰到的问题
Java提供了许多工具帮助开发者进行多线程程序的编写，但是菜鸡程序员依旧写不好多线程程序