Java 线程安全

原创已于 2022-11-04 21:17:32 修改 · 161 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #jvm #开发语言

于 2022-11-04 21:17:21 首次发布

1、线程安全问题

首先看一下下面代码

class TestThread implements Runnable {
    int count = 0;
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
        System.out.println(Thread.currentThread().getName() + " 执行完成 ！！");
    }
}
public class Test {
    public static void main(String[] args) {
        TestThread t = new TestThread();
        //启动三个线程
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        //主线程休眠等待上面三个线程执行完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //输出三个线程执行完成之后的结果
        System.out.println("执行结果为：" + t.count);
    }
}

Thread-2 执行完成 ！！
Thread-0 执行完成 ！！
Thread-1 执行完成 ！！
执行结果为：14311

按照我们的想法，每个线程将 count 加 1 加 10000 次，所以最后的结果应该为 30000 ，但是输出的结果并不是这样。

下面我们来看看线程的工作模式

每一个线程都有一个自己的工作内存，线程工作时都是在自己的内存里进行的。当线程需要操作公共资源时，首先需要从主内存中拷贝一份到自己的工作内存中，然后在自己的工作内存中进行操作，操作完成后再将结果写入主内存。

在上述工作模式中，当多个线程同时操作一个公共资源时，就会存在线程安全问题。例如前面的示例代码中，三个线程都需要操作一个公共资源 count ，假设当前的 count 值为 100 ，当线程 1 在执行时，先将 count 拷贝一份到自己的工作内存中，然后在自己的内存中进行操作，如果这时线程 2 也在执行，在线程 1 将操作完成的结果写入主内存之前，线程 2 就将 count 拷贝到自己的内存中执行，所以此时这两个线程中的 count 的值都是 100，当他们都完成加 1 操作后，将结果写回主内存中，由于其计算结果都是 101 ，所以最后都是将 101 写入到主内存中，虽然两个线程都进行了一次加 1 操作，但是最后的结果却是只相当于加了一次 1 。

2、常用的保证线程安全的方法

synchronized 关键字

synchronized 可以用来修饰方法或者代码块，用来保证线程同步，在多个线程操作同一个资源的时候确保只有一个线程能获取资源，其他线程处于阻塞状态，当 synchronized 修饰的方法或代码块执行完之后会自动将锁释放，这时其他的线程再争夺这把锁获取资源。

synchronized 用来修饰方法时，若修饰的是静态方法，则该类的方法同一时间只能被调用一次。若修饰的是非静态方法，则该类的实例对象的该方法同一时间只能被调用一次，而该类的不同对象的该方法不受影响。

在上面的例子中，可以用 synchronized 修饰 run 方法，由于我们只创建了一个 TestThread 类的实例对象，所以当有线程正在执行这个 run 方法时，其他线程就进入阻塞状态等待，从而可以确保同一时间只有一个线程在操作 count 。

class TestThread implements Runnable {
    int count = 0;
    @Override
    public synchronized void run() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
        System.out.println(Thread.currentThread().getName() + " 执行完成 ！！");
    }
}

Thread-0 执行完成 ！！
Thread-2 执行完成 ！！
Thread-1 执行完成 ！！
执行结果为：30000

用 synchronized 修饰代码块时，需要传入一个实例对象，当某个线程执行到这一段代码时，若该对象没有被锁住则进入执行代码，同时将该对象锁住，防止其他线程进入；若执行到该代码时，该对象已经被锁住，则进入阻塞状态等待锁释放，然后争夺锁进入执行。

在上面的示例代码中，我们可以创建一个对象用来充当锁，或者直接锁住对象本身，当其他线程执行到对应的代码块时，若该对象被锁住则进入阻塞状态等待，从而确保同一时间只有一个线程在操作公共资源。

class TestThread implements Runnable {
    int count = 0;
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            synchronized (this) {
                count++;
            }
        }
        System.out.println(Thread.currentThread().getName() + " 执行完成 ！！");
    }
}

Lock 接口

Lock 接口的实现类有如下几种：

一般情况下我们使用 ReentrantLock 即可，ReentrantLock 类与 synchronized 关键字效果类似。Lock 接口有两个常用的方法 lock() 和 unlock()，分别是获得锁和释放锁。在使用 Lock 接口保证线程同步时，为了确保某个线程获得锁后，最终锁能够释放，所以 Lock 接口通常按如下方法使用。

Lock lock = new ReentrantLock();    //创建锁
lock.lock();    //获得锁
try {
    //同步操作
} finally {
    lock.unlock();    //释放锁
}

注意不能把获得锁的操作放在 try 语句块中，如果获取锁的操作放在 try 语句块中，但执行获取锁的操作时出现了异常，这时抛出异常的同时会使得锁无法被释放。

回到上面的例子中，我们同样可以运用 Lock 接口来保证线程安全。具体实现代码如下：

class TestThread implements Runnable {
    int count = 0;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 执行完成 ！！");
    }
}