Java多线程 – synchronized

Java多线程 – synchronized

竞态

所谓竞态(race condition)是指,当多个线程访问和操作同一个对象时,最终执行结果与执行时序有关,可能正确也可能不正确。

如下示例:

public class CounterThread extends Thread {
    private static int counter = 0;

    public static void main(String[] args) throws Exception {
        int num = 1000;
        Thread[] threads = new Thread[num];
        for (int i = 0; i < num; i++) {
            threads[i] = new CounterThread();
            threads[i].start();
        }
        for (int i = 0; i < num; i++) {
            threads[i].join();
        }
        System.out.println(counter);
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter++;
        }
    }
}

输出:

998849

上文代码中共享静态变量counter,初始值为0,在main方法中创建了1000个线程,每个线程对counter循环加1000次,main线程等待所有线程结束后输出counter的值。

期望的结果是100万,但实际99万多。为什么会这样呢,因为counter++这个操作不是原子操作,它分为三个步骤:

  1. 取counter的当前值
  2. 在当前基础上加1
  3. 将新值重新赋值给counter

两个线程可能同时执行第一步,取到了相同的counter值,比如都取到了100,第一个线程执行完后counter变为101,而第二个线程执行完后还是101,最终的结果就与期望不符。解决办法:

  1. 使用synchronized关键字

  2. 使用显式锁

  3. 使用原子变量

内存可见性

多个线程可以共享访问和操作相同的变量,但一个线程对一个共享变量的修改,另一个线程不一定马上就能看到,甚至永远也看不到。

如下示例:

public class VisibilityDemo {
    private static boolean shutdown = false;

    public static void main(String[] args) throws Exception {
        new HelloThread().start();
        Thread.sleep(1000);
        shutdown = true;
        System.out.println("exit main");
    }

    static class HelloThread extends Thread {
        @Override
        public void run() {
            while (!shutdown) {
                System.out.println("run...");
            }
            System.out.println("exit hello");
        }
    }
}

在这个程序中,有一个共享的boolean变量shutdown,初始为false,HelloThread在shutdown不为true的情况下一直死循环,当shutdown为true时退出并输出”exit hello”,main线程启动HelloThread后睡了一会,然后设置shutdown为true,最后输出”exitmain”。

期望的结果是两个线程都退出,但实际执行,很可能会发现HelloThread永远都不会退出,也就是说,在HelloThread执行流看来,shutdown永远为false,即使main线程已经更改为了true。

这是怎么回事呢?这就是内存可见性问题。在计算机系统中,除了内存,数据还会被缓存在CPU的寄存器以及各级缓存中,当访问一个变量时,可能直接从寄存器或CPU缓存中获取,而不一定到内存中去取,当修改一个变量时,也可能是先写到缓存中,而稍后才会同步更新到内存中。在单线程的程序中,这一般不是个问题,但在多线程的程序中,尤其是在有多CPU的情况下,这就是个严重的问题。一个线程对内存的修改,另一个线程看不到,一是修改没有及时同步到内存,二是另一个线程根本就没从内存读。

怎么解决这个问题呢?有多种方法:

  1. 使用volatile关键字
  2. 使用synchronized关键字或显式锁同步

synchronized

使用synchronized关键字,修复上面竞态中出现问题的代码。

public class Counter {
    private int count;

    public synchronized void incr() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}
public class CounterThread extends Thread {

    Counter counter;

    public CounterThread(Counter counter) {
        this.counter = counter;
    }

    public static void main(String[] args) throws Exception {
        int num = 1000;
        Thread[] threads = new Thread[num];
        Counter counter = new Counter();
        for (int i = 0; i < num; i++) {
            threads[i] = new CounterThread(counter);
            threads[i].start();
        }
        for (int i = 0; i < num; i++) {
            threads[i].join();
        }
        System.out.println(counter.getCount());
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.incr();
        }
    }
}

多次运行,均输出:

1000000

synchronized实例方法大致如下:

  1. 尝试获取锁,如果能够获取锁,继续下一步,否则加入等待对了,阻塞并等待唤醒。
  2. 执行实例方法体代码
  3. 释放锁,如果等待队列上有等待的线程,从中取一个并唤醒,如果有多个等待线程,唤醒哪一个是不一定的,不保证公平性。

synchronized特点

  1. 可重入性

    对同一个执行线程,它在获得了锁之后,在调用其他需要同样锁的代码时,可以直接调用。

  2. 内存可见性

    在释放锁时,所有写入都会写回内存,而获得锁后,都会从内存中读最新数据。使用synchronized的成本有点高,有一个更轻量级的方式,那就是给变量加修饰符volatile。

  3. 死锁

    使用synchronized或者其他锁,要注意死锁。所谓死锁就是类似这种现象,比如,有a、b两个线程,a持有锁A,在等待锁B,而b持有锁B,在等待锁A,a和b陷入了互相等待,最后谁都执行不下去。

说点什么

This site uses Akismet to reduce spam. Learn how your comment data is processed.

  Subscribe  
提醒