Java同步的几种实现方式

Java提供了很多同步操作，比如synchronized关键字、wait/notifyAll、ReentrantLock、Condition、一些并发包下的工具类、Semaphore，ThreadLocal、AbstractQueuedSynchronizer等。
Concurrent下的线程安全集合 参考：Concurrent下的线程安全集合

ReentrantLock可重入锁

ReentrantLock可重入锁是jdk内置的一个锁对象，可以用来实现同步，基本使用方法如下：

public class ReentrantLockTest {

private ReentrantLock lock = new ReentrantLock();

public void execute() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " do something synchronize");
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
} finally {
lock.unlock();
}
}

public static void main(String[] args) {
ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
reentrantLockTest.execute();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
reentrantLockTest.execute();
}
});
thread1.start();
thread2.start();
}

}

输出：

Thread-0 do something synchronize
// 隔了5秒钟 输入下面
Thread-1 do something synchronize

这个例子表示同一时间段只能有1个线程执行execute方法。可重入锁中可重入表示的意义在于对于同一个线程，可以继续调用加锁的方法，而不会被挂起。可重入锁内部维护一个计数器，对于同一个线程调用lock方法，计数器+1，调用unlock方法，计数器-1。举个例子再次说明一下可重入的意思，在一个加锁方法execute中调用另外一个加锁方法anotherLock并不会被挂起，可以直接调用(调用execute方法时计数器+1，然后内部又调用了anotherLock方法，计数器+1，变成了2)：

public void execute() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " do something synchronize");
try {
anotherLock();
Thread.sleep(5000l);
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
} finally {
lock.unlock();
}
}

public void anotherLock() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " invoke anotherLock");
} finally {
lock.unlock();
}
}

输出：

Thread-0 do something synchronize
Thread-0 invoke anotherLock
// 隔了5秒钟 输入下面
Thread-1 do something synchronize
Thread-1 invoke anotherLock

synchronized关键字

synchronized关键跟ReentrantLock一样，也支持可重入锁。但是它是一个关键字，是一种语法级别的同步方式，称为内置锁。
同步和锁机制：
在 java 虚拟机中, 每个对象( Object 和 class )通过某种逻辑关联监视器,每个监视器和一个对象引用相关联, 为了实现监视器的互斥功能, 每个对象都关联着一把锁. 
synchronized是基于监视器（monitor）实现来实现方法同步和代码块同步。synchronized是基于JVM层面的，使用的是对象内置的锁。静态方法锁住的是该class的监视器，实例方法锁住的是对应实例的监视器。同步是使用monitorenter和monitorexit指令实现的，monitorenter尝试获取对象的锁，如果该对象没被锁定或者当前线程已经获取了锁，则把锁的计数器+1，同样monitorexit把锁的计数器-1。因此synchronized对于同一个线程是可重入的。
一旦方法或者代码块被 synchronized 修饰, 那么这个部分就放入了监视器的监视区域, 确保一次只能有一个线程执行该部分的代码, 线程在获取锁之前不允许执行该部分的代码 
另外 java 还提供了显式监视器( Lock )和隐式监视器( synchronized )两种锁方案但是监视器锁本质又是依赖于底层的操作系统的互斥锁（Mutex Lock）来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统互斥锁（Mutex Lock）所实现的锁我们称之为“重量级锁”。
参考：深入理解java：2.2. 同步锁Synchronized及其实现原理synchronized同步方法：即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。同步方法默认用this或者当前类class对象作为锁；
synchronized同步代码块： 
即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。代码如： 
synchronized(object){ 
}注：同步是一种高开销的操作，因此应该尽量减少同步的内容。 
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

public class SynchronizedKeyWordTest {

public synchronized void execute() {
System.out.println(Thread.currentThread().getName() + " do something synchronize");
try {
anotherLock();
Thread.sleep(5000l);
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
}

public synchronized void anotherLock() {
System.out.println(Thread.currentThread().getName() + " invoke anotherLock");
}

public static void main(String[] args) {
SynchronizedKeyWordTest reentrantLockTest = new SynchronizedKeyWordTest();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
reentrantLockTest.execute();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
reentrantLockTest.execute();
}
});
thread1.start();
thread2.start();
}

}

输出结果跟ReentrantLock一样，这个例子说明内置锁可以作用在方法上。它还可以作用到变量，静态方法上。synchronized跟ReentrantLock相比，有几点局限性：加锁的时候不能设置超时。ReentrantLock有提供tryLock方法，可以设置超时时间，如果超过了这个时间并且没有获取到锁，就会放弃，而synchronized却没有这种功能
ReentrantLock可以使用多个Condition，而synchronized却只能有1个
不能中断一个试图获得锁的线程
ReentrantLock可以选择公平锁和非公平锁
ReentrantLock可以获得正在等待线程的个数，计数器等

Condition条件对象

条件对象的意义在于对于一个已经获取锁的线程，如果还需要等待其他条件才能继续执行的情况下，才会使用Condition条件对象。

public class ConditionTest {

public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " run");
System.out.println(Thread.currentThread().getName() + " wait for condition");
try {
condition.await();
System.out.println(Thread.currentThread().getName() + " continue");
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
} finally {
lock.unlock();
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try {

ef7a
System.out.println(Thread.currentThread().getName() + " run");
System.out.println(Thread.currentThread().getName() + " sleep 5 secs");
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
condition.signalAll();
} finally {
lock.unlock();
}
}
});
thread1.start();
thread2.start();
}

}

这个例子中thread1执行到condition.await()时，当前线程会被挂起，直到thread2调用了condition.signalAll()方法之后，thread1才会重新被激活执行。这里需要注意的是thread1调用Condition的await方法之后，thread1线程释放锁，然后马上加入到Condition的等待队列，由于thread1释放了锁，thread2获得锁并执行，thread2执行signalAll方法之后，Condition中的等待队列thread1被取出并加入到AQS中，接下来thread2执行完毕之后释放锁，由于thread1已经在AQS的等待队列中，所以thread1被唤醒，继续执行。

wait/notifyAll 方式

wait/notifyAll方式跟ReentrantLock/Condition方式的原理是一样的。Java中每个对象都拥有一个内置锁，在内置锁中调用wait，notify方法相当于调用锁的Condition条件对象的await和signalAll方法。使用wait/notifyAll实现上面的那个Condition例子：

public class WaitNotifyAllTest {

public synchronized void doWait() {
System.out.println(Thread.currentThread().getName() + " run");
System.out.println(Thread.currentThread().getName() + " wait for condition");
try {
this.wait();
System.out.println(Thread.currentThread().getName() + " continue");
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
}

public synchronized void doNotify() {
try {
System.out.println(Thread.currentThread().getName() + " run");
System.out.println(Thread.currentThread().getName() + " sleep 5 secs");
Thread.sleep(5000l);
this.notifyAll();
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
}

public static void main(String[] args) {
WaitNotifyAllTest waitNotifyAllTest = new WaitNotifyAllTest();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
waitNotifyAllTest.doWait();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
waitNotifyAllTest.doNotify();
}
});
thread1.start();
thread2.start();
}

}

这里需要注意的是由于Condition是由锁创建的，所以调用wait/notifyAll方法的时候需要获得当前线程的锁，否则会发生IllegalMonitorStateException异常。wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。 

ThreadLocal

ThreadLocal是一种把变量放到线程本地的方式来实现线程同步的。比如SimpleDateFormat不是一个线程安全的类，可以使用ThreadLocal实现同步。

public class ThreadLocalTest {

private static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
@Override
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};

public static void main(String[] args) {
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
Date date = new Date();
System.out.println(dateFormatThreadLocal.get().format(date));
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
Date date = new Date();
System.out.println(dateFormatThreadLocal.get().format(date));
}
});
thread1.start();
thread2.start();
}

}

Semaphore信号量

Semaphore信号量被用于控制特定资源在同一个时间被访问的个数。类似连接池的概念，保证资源可以被合理的使用。可以使用构造器初始化资源个数：

public class SemaphoreTest {

private static Semaphore semaphore = new Semaphore(2);

public static void main(String[] args) {
for(int i = 0; i < 5; i ++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + " " + new Date());
Thread.sleep(5000l);
semaphore.release();
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
}
}
}).start();
}
}

}

输出：

Thread-1 Mon Apr 18 18:03:46 CST 2016
Thread-0 Mon Apr 18 18:03:46 CST 2016
Thread-3 Mon Apr 18 18:03:51 CST 2016
Thread-2 Mon Apr 18 18:03:51 CST 2016
Thread-4 Mon Apr 18 18:03:56 CST 2016

并发包下的工具类

一般情况下，我们不会使用wait/notifyAll或者ReentrantLock这种比较底层的类，而是使用并发包下提供的一些工具类。

CountDownLatch

CountDownLatch是一个计数器，它的构造方法中需要设置一个数值，用来设定计数的次数。每次调用countDown()方法之后，这个计数器都会减去1，CountDownLatch会一直阻塞着调用await()方法的线程，直到计数器的值变为0。

public class CountDownLatchTest {

public static void main(String[] args) {
CountDownLatch countDownLatch = new CountDownLatch(5);
for(int i = 0; i < 5; i ++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " " + new Date() + " run");
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
countDownLatch.countDown();
}
}).start();
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("all thread over");
}

}

输出：

Thread-2 Mon Apr 18 18:18:30 CST 2016 run
Thread-3 Mon Apr 18 18:18:30 CST 2016 run
Thread-4 Mon Apr 18 18:18:30 CST 2016 run
Thread-0 Mon Apr 18 18:18:30 CST 2016 run
Thread-1 Mon Apr 18 18:18:30 CST 2016 run
all thread over

CyclicBarrier

CyclicBarrier阻塞调用的线程，直到条件满足时，阻塞的线程同时被打开。调用await()方法的时候，这个线程就会被阻塞，当调用await()的线程数量到达屏障数的时候，主线程就会取消所有被阻塞线程的状态。在CyclicBarrier的构造方法中，还可以设置一个barrierAction。在所有的屏障都到达之后，会启动一个线程来运行这里面的代码。

public class CyclicBarrierTest {

public static void main(String[] args) {
Random random = new Random();
CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
for(int i = 0; i < 5; i ++) {
new Thread(new Runnable() {
@Override
public void run() {
int secs = random.nextInt(5);
System.out.println(Thread.currentThread().getName() + " " + new Date() + " run, sleep " + secs + " secs");
try {
Thread.sleep(secs * 1000);
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + new Date() + " runs over");
}
}).start();
}
}

}

相比CountDownLatch，CyclicBarrier是可以被循环使用的，而且遇到线程中断等情况时，还可以利用reset()方法，重置计数器，从这些方面来说，CyclicBarrier会比CountDownLatch更加灵活一些。

AbstractQueuedSynchronizer

AQS是很多同步工具类的基础，比如ReentrentLock里的公平锁和非公平锁，Semaphore里的公平锁和非公平锁，CountDownLatch里的锁等他们的底层都是使用AbstractQueuedSynchronizer完成的。基于AbstractQueuedSynchronizer自定义实现一个独占锁：

public class MySynchronizer extends AbstractQueuedSynchronizer {

@Override
protected boolean tryAcquire(int arg) {
if(compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}

@Override
protected boolean tryRelease(int arg) {
setState(0);
setExclusiveOwnerThread(null);
return true;
}

public void lock() {
acquire(1);
}

public void unlock() {
release(1);
}

public static void main(String[] args) {
MySynchronizer mySynchronizer = new MySynchronizer();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
mySynchronizer.lock();
try {
System.out.println(Thread.currentThread().getName() + " run");
System.out.println(Thread.currentThread().getName() + " will sleep 5 secs");
try {
Thread.sleep(5000l);
System.out.println(Thread.currentThread().getName() + " continue");
} catch (InterruptedException e) {
System.err.println(Thread.currentThread().getName() + " interrupted");
Thread.currentThread().interrupt();
}
} finally {
mySynchronizer.unlock();
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
mySynchronizer.lock();
try {
System.out.println(Thread.currentThread().getName() + " run");
} finally {
mySynchronizer.unlock();
}
}
});
thread1.start();
thread2.start();
}

}

MySynchronizer并没有实现可重入功能，只是简单的一个独占锁。原文出处：Java实现同步的几种方式
参考文档：java笔记--关于线程同步（7种同步方式）