第三百二十二节 Java线程教程 - Java原子变量、Java显式锁

Java线程教程 - Java原子变量

新线程并发包

java.util.concurrent和java.util.concurrent.atomic和java.util.concurrent.locks包括非常有用的并发构造。

线程并发包以四种方式支持并发。

• 原子变量
• 锁
• 同步器
• 并发集合

原子变量

原子变量类的命名类似于AtomicXxx，例如，AtomicInteger类用于表示一个int变量。

原子变量可用于在不使用任何锁的情况下以原子方式对单个变量执行多个指令。

• 标量原子变量类

  AtomicInteger，AtomicLong和AtomicBoolean类分别支持对原始数据类型int，long和boolean的操作。

  当引用变量需要以原子方式更新时，AtomicReference类用于处理引用数据类型。

• 原子数组类

  有三个类称为AtomicIntegerArray，AtomicLongArray和AtomicReferenceArray，它们表示一个int，long和引用类型的数组，其元素可以进行原子性更新。

• 原子字段更新程序类

  有三个类称为AtomicLongFieldUpdater，AtomicIntegerFieldUpdater和AtomicReferenceFieldUpdater，可用于使用反射以原子方式更新类的易失性字段。

  要获得对这些类的对象的引用，您需要使用他们的工厂方法newUpdater()。

• 原子复合变量类

例子

以下代码显示如何使用AtomicLong类来创建计数器。

import java.util.concurrent.atomic.AtomicLong;

public class AtomicCounter {
  private AtomicLong value = new AtomicLong(0L);

  public long next() {
    return value.incrementAndGet();
  }
}

Java线程教程 - Java显式锁

显式锁定机制可以用于协调对多线程环境中的共享资源的访问。

在java.util.concurrent.locks包中声明的Lock接口定义了显式锁定操作。

ReentrantLock类在同一个包中，是Lock接口的具体实现。

Lock接口声明如下：

public interface Lock {
  void lock();

  Condition newCondition();

  void lockInterruptibly() throws InterruptedException;

  boolean tryLock();

  boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

  void unlock();
}

lock()方法获取一个锁的行为与使用synchronized关键字相同。

我们必须在完成锁定后通过调用Lock接口的unlock()方法释放锁定。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
  // Instantiate the lock object
  private Lock myLock = new ReentrantLock();

  public void updateResource() {

    try {
      // Acquire the lock
      myLock.lock();
    } finally {
      // Release the lock
      myLock.unlock();
    }
  }
}

例子

下面的代码模拟哲学家，假设ReentrantLock类的一个对象表示一个fork。

import java.util.concurrent.locks.Lock;

class Philosopher {
  private Lock leftFork;
  private Lock rightFork;
  private String name; // Philosopher"s name

  public Philosopher(Lock leftFork, Lock rightFork, String name) {
    this.leftFork = leftFork;
    this.rightFork = rightFork;
    this.name = name;
  }

  public void think() {
    System.out.println(name + "  is thinking...");
  }

  public void eat() {
    if (leftFork.tryLock()) {
      try {
        if (rightFork.tryLock()) {
          try {
            System.out.println(name + "  is eating...");
          } finally {
            rightFork.unlock();
          }
        }
      } finally {
        leftFork.unlock();
      }
    }
  }
}

例2

ReentrantReadWriteLock类是ReadWriteLock接口的实现。只有一个线程可以保持ReentrantReadWriteLock的写锁，而多个线程可以保持其读锁。

下面的代码演示了ReentrantReadWriteLock的用法。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
  private int value;
  private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  private Lock rLock = rwLock.readLock();
  private Lock wLock = rwLock.writeLock();

  public Main(int value) {
    this.value = value;
  }

  public int getValue() {
    rLock.lock();
    try {
      return this.value;
    } finally {
      rLock.unlock();
    }
  }

  public void setValue(int value) {
    wLock.lock();
    try {
      this.value = value;
    } finally {
      wLock.unlock();
    }
  }
}