关于线程中的同步策略,或者说是线程之间的协作,如何去进行?
关于这个问题,我们自然想到Java中线程之间能够共享的在堆区和方法区,应该从这里入手比较好。而具体工具我们能想到啥呢?利用 锁、信号量、条件变量,CAS?具体如何做呢?我们这里从一个常见的问题来入手解决,进而了解在Java中线程的常见同步策略有哪些。
目录
问题描述
使用两个线程交替打印出0-99的数字。
问题思考
两个线程交替打印0-99的数字,说白了就是线程a打印0,2,4,....,98。线程b打印1,3,5,...,99。这不就是线程a打印偶数,线程b打印奇数嘛。有了这个结论,我们可以大致得出两个线程的打印结构。
//线程a
for (int i = 0; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
//同步策略
}
//线程b
for (int i = 0; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
//同步策略
}
问题解决
利用锁
java中常用的锁机制有synchronized关键字和juc中的ReentrantLock锁。关于synchronized和juc中的ReentrantLock锁的差异我后面将出文具体说明,这里我们先用synchronized来解决这个问题。
synchronized要锁住一个对象才行,常见的有锁住对象自己,锁住对象所属的类,这里我们新建一个Integer对象,作为锁的对象,于是我们能够写出这样的代码。
Integer lock = new Integer(-1);
new Thread(()->{
synchronized (lock){
try {
for (int i = 0; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
lock.notify(); //唤醒另一个线程
lock.wait(); //阻塞自己,等待另一个线程唤醒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"a").start();
TimeUnit.MILLISECONDS.sleep(500); //因为两个线程的第一次打印只需要拿到锁而不需要唤醒。保证a线程先进入,即要先打印0
new Thread(()->{
synchronized (lock){
try {
for (int i = 1; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
lock.notify();//唤醒另一个线程
lock.wait();//阻塞自己,等待另一个线程唤醒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"b").start();
这里有几个点要注意一下。
- 中间的延迟是保证线程1线打印。
- 其中要注意的是wait操作会提前释放锁,这样上面的程序才不会导致死锁,并且这种wait操作需要其他线程的notify操作或者notifyAll操作才能使得该线程被唤醒继续争取锁。
条件变量
这里条件变量我们使用ReentrantLock对象获得,通过其newCondition方法。Java的条件变量这是也是JUC包下的。
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(()->{
lock.lock();
try {
for (int i = 0; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
condition.signal();//
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
},"a").start();
TimeUnit.MILLISECONDS.sleep(500); //同样地原因
new Thread(()->{
lock.lock();
try {
for (int i = 1; i < 100; i+=2) {
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
condition.signal();
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
},"b").start();
其实类似于直接使用锁,只是条件变量的适用范围更广泛,可以在同一个代码块中,优雅地实现多个条件的线程挂起与唤醒操作。
信号量
Java中也可以使用JUC包中的Semaphore,其底层与ReentrantLock一样也是AQS思想。不过Semaphore是共享模式,ReentrantLock底层是独占模式。关于相关底层数据结构的有时间我会在后期进行一个源码剖析比较。这里我们直接上解决方案。
Semaphore semaphore1 = new Semaphore(1); //更简单一些,不需要时间延迟,代表线程a先开始
Semaphore semaphore2 = new Semaphore(0); //线程b一开始为0,即使先进入也得阻塞
new Thread(()->{
for (int i = 0; i < 100; i+=2) {
try {
semaphore1.acquire();//消耗,初始或线程b提供
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore2.release();//生产,生产给线程b
}
}
},"a").start();
new Thread(()->{
for (int i = 1; i < 100; i+=2) {
try {
semaphore2.acquire(); //消耗,线程a提供
System.out.println(Thread.currentThread().getName()+":"+i);
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore1.release();//生产,生产给线程a
}
}
},"b").start();
有没有感觉信号量方式的程序实现方式非常的明亮简洁?这里使用的acquire方法和release方法分别代表消耗和生产——这其实能够非常好地模拟生产-消费者模型。两个信号量代表两个标识,每个线程执行前需要消耗这个标识,消耗完成后会提供给另一个线程对应的标识,完成同步操作。
CAS思想
我们直到CAS思想其实就是乐观锁的思想,已经在很多数据结构上有运用,比如ConcurrentHashMap,ConcurentLinkedDeque等,其中JUC的原子类更是运用了该思想,我们这里就用AtomicInteger来实现这个解决方案。
private static volatile boolean flag=false; //可见性问题,写回主内存
private static void method1(){ //CAS
AtomicInteger atomicInteger = new AtomicInteger(1);
new Thread(()->{
while(atomicInteger.get()<100){ //自旋
if(flag==true&&atomicInteger.get()%2==0){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+atomicInteger.getAndIncrement());
flag=false;
}
}
},"a").start();
new Thread(()->{
while(atomicInteger.get()<100){//自旋
if(flag==false&&atomicInteger.get()%2==1){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+atomicInteger.getAndIncrement());
flag=true;
}
}
},"b").start();
}
总结
线程的通信机制除了简单的join插队,yield让步之外,还能有更多的策略进行通信,不过最底层还是要追溯到java中线程中共享的机制,即能够共享堆区和方法区。基于此才出现了各式各样的方法。