Java并发包详解

一、volatile关键字

volatile关键字用于保证变量在多线程之间的可见性。通常情况下，线程之间是互相不可见的，也就是说一个线程对变量的修改，其他线程不会立即感知到。使用volatile声明的变量可以保证当一个线程修改了该变量的值之后，其他线程能够立即感知到这个变化。

public class VolatileTest {
    private volatile int count = 0;

    public void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.increment();
            }
          }).start();
        }

        Thread.sleep(3000);
        System.out.println(test.count);
    }
}

上述代码可以看出，由于count变量被volatile修饰，所以多个线程对该变量的修改是可见的，最终输出的count变量的值是5000，而不是一个小于5000的数值。

二、synchronized关键字

synchronized关键字是Java中最基本的同步关键字，它用于保证多个线程之间的互斥访问，允许在同一时刻只有一个线程访问共享资源。

public class SynchronizedTest {
    private int count = 0;

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

    public static void main(String[] args) throws InterruptedException {
        final SynchronizedTest test = new SynchronizedTest();

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.increment();
            }
          }).start();
        }

        Thread.sleep(3000);
        System.out.println(test.count);
    }
}

上述代码中，count变量被synchronized关键字修饰的increment方法访问。由于synchronized保证了同一时刻只有一个线程可以进入该方法，所以最终输出的count变量的值是5000。

三、ReentrantLock类

ReentrantLock类是Java中可重入锁的一种实现方式，也可以实现多个线程之间的互斥访问。与synchronized关键字不同的是，ReentrantLock类可以更加精细地控制锁的获取和释放，同时还支持公平锁和非公平锁。

public class ReentrantLockTest {
    private ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ReentrantLockTest test = new ReentrantLockTest();

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.increment();
            }
          }).start();
        }

        Thread.sleep(3000);
        System.out.println(test.count);
    }
}

上述代码中，ReentrantLock类实现了多个线程之间的互斥访问。在increment方法中，首先需要调用lock方法获取锁，保证同一时刻只有一个线程可以修改count变量的值，最后需要调用unlock方法释放锁。最终输出的count变量的值是5000。

四、Condition接口

Condition接口是在Java 5中引入的，它提供了类似于Object的wait和notify方法的功能，但可以选择性地地通知某些线程。与使用synchronized关键字和Object的wait方法不同，使用Condition对象可以在等待信号时释放锁。

public class ConditionTest {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void waitForCount() throws InterruptedException {
        lock.lock();
        try {
            while (count  {
            try {
                test.waitForCount();
                System.out.println("count has reached 5000");
            } catch (InterruptedException ex) {
                // ...
            }
        }).start();

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.increment();
            }
          }).start();
        }

        Thread.sleep(3000);
    }
}

上述代码中，ConditionTest类中的waitForCount方法会线程等待，直到count变量的值达到5000。在increment方法中，除了对count变量进行修改之外，还会调用signalAll方法通知所有等待线程。最终输出的是“count has reached 5000”。

五、ReadWriteLock类

除了ReentrantLock之外，Java并发包中还提供了ReadWriteLock类，它可以使得多个线程同时读取共享变量，但是在有线程写入时，所有读线程会被阻塞。

public class ReadWriteLockTest {
    private int count = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void increment() {
        lock.writeLock().lock();

        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void printCount() {
        lock.readLock().lock();

        try {
            System.out.println(count);
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ReadWriteLockTest test = new ReadWriteLockTest();

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.increment();
            }
          }).start();
        }

        for (int i = 0; i  {
            for (int j = 0; j < 1000; j++) {
              test.printCount();
            }
          }).start();
        }

        Thread.sleep(3000);
    }
}

上述代码中，increment方法使用写锁进行同步，而printCount方法使用读锁进行同步。由于读锁是共享锁，多个线程可以同时获得对共享变量的访问权。最终输出的count变量的值会大于等于5000。