Java实现同步的几种方式
2017-11-06 18:25
519 查看
转自 http://fangjian0423.github.io/2016/04/18/java-synchronize-way/
Java提供了很多同步操作,比如synchronized关键字、wait/notifyAll、ReentrantLock、Condition、一些并发包下的工具类、Semaphore,ThreadLocal、AbstractQueuedSynchronizer等。
本文简单说明一下这几种方式的使用。
ReentrantLock可重入锁是jdk内置的一个锁对象,可以用来实现同步,基本使用方法如下:
输出:
这个例子表示同一时间段只能有1个线程执行execute方法。
可重入锁中可重入表示的意义在于对于同一个线程,可以继续调用加锁的方法,而不会被挂起。可重入锁内部维护一个计数器,对于同一个线程调用lock方法,计数器+1,调用unlock方法,计数器-1。
举个例子再次说明一下可重入的意思,在一个加锁方法execute中调用另外一个加锁方法anotherLock并不会被挂起,可以直接调用(调用execute方法时计数器+1,然后内部又调用了anotherLock方法,计数器+1,变成了2):
输出:
synchronized关键跟ReentrantLock一样,也支持可重入锁。但是它是一个关键字,是一种语法级别的同步方式,称为内置锁:
输出结果跟ReentrantLock一样,这个例子说明内置锁可以作用在方法上。它还可以作用到变量,静态方法上。
synchronized跟ReentrantLock相比,有几点局限性:
加锁的时候不能设置超时。ReentrantLock有提供tryLock方法,可以设置超时时间,如果超过了这个时间并且没有获取到锁,就会放弃,而synchronized却没有这种功能
ReentrantLock可以使用多个Condition,而synchronized却只能有1个
不能中断一个试图获得锁的线程
ReentrantLock可以选择公平锁和非公平锁
ReentrantLock可以获得正在等待线程的个数,计数器等
条件对象的意义在于对于一个已经获取锁的线程,如果还需要等待其他条件才能继续执行的情况下,才会使用Condition条件对象。
这个例子中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方式跟ReentrantLock/Condition方式的原理是一样的。
Java中每个对象都拥有一个内置锁,在内置锁中调用wait,notify方法相当于调用锁的Condition条件对象的await和signalAll方法。
使用wait/notifyAll实现上面的那个Condition例子:
这里需要注意的是由于Condition是由锁创建的,所以调用wait/notifyAll方法的时候需要获得当前线程的锁,否则会发生IllegalMonitorStateException异常。
ThreadLocal是一种把变量放到线程本地的方式来实现线程同步的。
比如SimpleDateFormat不是一个线程安全的类,可以使用ThreadLocal实现同步。
Semaphore信号量被用于控制特定资源在同一个时间被访问的个数。类似连接池的概念,保证资源可以被合理的使用。可以使用构造器初始化资源个数:
输出:
一般情况下,我们不会使用wait/notifyAll或者ReentrantLock这种比较底层的类,而是使用并发包下提供的一些工具类。
CountDownLatch是一个计数器,它的构造方法中需要设置一个数值,用来设定计数的次数。每次调用countDown()方法之后,这个计数器都会减去1,CountDownLatch会一直阻塞着调用await()方法的线程,直到计数器的值变为0。
输出:
CyclicBarrier阻塞调用的线程,直到条件满足时,阻塞的线程同时被打开。
调用await()方法的时候,这个线程就会被阻塞,当调用await()的线程数量到达屏障数的时候,主线程就会取消所有被阻塞线程的状态。
在CyclicBarrier的构造方法中,还可以设置一个barrierAction。
在所有的屏障都到达之后,会启动一个线程来运行这里面的代码。
相比CountDownLatch,CyclicBarrier是可以被循环使用的,而且遇到线程中断等情况时,还可以利用reset()方法,重置计数器,从这些方面来说,CyclicBarrier会比CountDownLatch更加灵活一些。
AQS是很多同步工具类的基础,比如ReentrentLock里的公平锁和非公平锁,Semaphore里的公平锁和非公平锁,CountDownLatch里的锁等他们的底层都是使用AbstractQueuedSynchronizer完成的。
基于AbstractQueuedSynchronizer自定义实现一个独占锁:
MySynchronizer并没有实现可重入功能,只是简单的一个独占锁。
Java提供了很多同步操作,比如synchronized关键字、wait/notifyAll、ReentrantLock、Condition、一些并发包下的工具类、Semaphore,ThreadLocal、AbstractQueuedSynchronizer等。
本文简单说明一下这几种方式的使用。
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一样,也支持可重入锁。但是它是一个关键字,是一种语法级别的同步方式,称为内置锁: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 { 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异常。
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实现同步的几种方式
- java实现同步的几种方式(总结)
- Java实现同步的几种方式
- java中实现同步的几种方式
- Java实现同步的几种方式
- Java实现同步的几种方式
- java同步机制的几种实现方式
- 不同数据源之间数据同步的几种实现方式
- 多线程有几种实现方法?同步有几种实现方法?静态同步方法和非静态有何不同?—— Java经典面试题系列
- java中同步加锁的几种方式
- JAVA中单例模式的几种实现方式
- java Thread编程(三) 同步的两种不同实现方式
- 原创:字符串和语句逆转的几种方式,可以任意组合,java实现
- Java多线程有哪几种实现方式? Java中的类如何保证线程安全? 请说明ThreadLocal的用法和适用场景(面试题)
- 用java实现邮件服务的几种方式总结
- java中有几种方法可以实现一个线程?用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用?
- 【Java】定时任务的几种实现方式
- java端RESTful web services的几种实现方式
- 不同数据源之间数据同步的几种实现方式