Java实现同步的几种方式
来源:互联网 发布:移动硬盘数据同步软件 编辑:程序博客网 时间:2024/06/05 06:35
转自 http://fangjian0423.github.io/2016/04/18/java-synchronize-way/
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 synchronizeThread-0 invoke anotherLock// 隔了5秒钟 输入下面Thread-1 do something synchronizeThread-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 2016Thread-0 Mon Apr 18 18:03:46 CST 2016Thread-3 Mon Apr 18 18:03:51 CST 2016Thread-2 Mon Apr 18 18:03:51 CST 2016Thread-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 runThread-3 Mon Apr 18 18:18:30 CST 2016 runThread-4 Mon Apr 18 18:18:30 CST 2016 runThread-0 Mon Apr 18 18:18:30 CST 2016 runThread-1 Mon Apr 18 18:18:30 CST 2016 runall 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多线程同步的几种方式
- GCD下的几种实现同步的方式
- GCD下的几种实现同步的方式
- 不同数据源之间数据同步的几种实现方式
- 不同数据源之间数据同步的几种实现方式
- 不同数据源之间数据同步的几种实现方式
- Linux中使用update-alternatives配置多个jdk
- Postman使用官方文档翻译--7设置介绍
- wmd的改进算法
- 【2017年cs231n学习笔记2】Lecture3 损失函数 最优化
- 自定义View之Paint
- Java实现同步的几种方式
- expected '=', ',', ';', 'asm' or '__attribute__' before xxx
- CCF认证201703-2--学生排队
- 记一次坑爹的爬虫经历
- SoapUI:mock(模拟) service的使用
- NFA(子集算法,DFA最小化)代码实现
- 【蓝桥杯】【放麦子】
- 团队天梯赛L1-015. 跟奥巴马一起画方块
- ListView获取Item里面的值