Condition

深入理解Condition

最新推荐文章于 2021-04-03 01:50:15 发布

转载最新推荐文章于 2021-04-03 01:50:15 发布 · 102 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/AshOfTime/p/10791842.html

本文详细解析了Java并发包中Condition的使用方法，对比了与Object类wait、notify的区别，包括响应中断、等待超时机制等特性，并通过实例展示了如何利用Condition实现线程间的协作，如多个等待队列和两线程交替打印。

　　Condition是为了替代Object的wait notify而设计出来的，其用法基本一致。

都需要先获得锁，然后在锁对象上建立等待队列，把调用wait的线程加入等待队列。
调用wait await后都会释放锁。
都支持等待超时机制。
Condition可响应中断也可以不响应中断(awaitUninterruptibly)，wait一定响应中断。
同一个lock可以有多个Condition队列，但同一个synchronized只有一个等待队列。

简单使用

　　主线程调用notify后子线程继续执行await后的内容。　　

package Condi;

import Semaphore.Pool.Run;

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

public class testCondition implements Runnable {
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();



    @Override
    public void run() {
        lock.lock();
        try {
            condition.await();
            System.out.println("等待结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new testCondition());
        thread.start();
        Thread.sleep(1000);
        System.out.println(thread.getState());
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

多个等待队列

　　　ThreadA ThreadB分别传入不同的Condition，两个Condition都是注册在同一个重入锁上的，在主线程上可以自由的选择只唤醒一个Condition上等待的线程。

package Condi;

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

public class ThreadA implements Runnable{
    private  ReentrantLock lock;
    private  Condition condition;

    public ThreadA(ReentrantLock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println("线程A获得锁");
            condition.await();
            System.out.println("线程A被唤醒");
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
        }
    }
}

package Condi;

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

public class ThreadB implements Runnable{
    private  ReentrantLock lock;
    private  Condition condition;

    public ThreadB(ReentrantLock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println("线程B获得锁");
            condition.await();
            System.out.println("线程B被唤醒");
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
        }
    }
}

package Condi;

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

public class wakeDifferent {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Thread threadA = new Thread(new ThreadA(lock,conditionA));
        Thread threadB = new Thread(new ThreadB(lock,conditionB));
        threadA.start();
        threadB.start();

        Thread.sleep(100);
        lock.lock();
        System.out.println("main获得锁");
        conditionB.signal();
        lock.unlock();
    }
}

两个线程交替打印

　　考虑AB两个线程，假如A线程获得了锁，必须保证下次获得锁的线程是B线程，而不能再是A线程，所以必须保证刚刚获得锁的线程不能第二次获得锁。

双等待队列

　　thread_1获得锁打印，await进入等待队列，进入等待队列的线程在没有被唤醒之前不能再次竞争锁，所以下一次一定是thread_2获得锁。thread_2获得锁后打印、唤醒thread_1、await后进入等待队列，同样因为awit的线程在被唤醒钱不能竞争锁，所以下一次一定是thread_1获得锁并打印。这样循环下去二者交替打印。

　　注意在main里调用thread的顺序要和thread中await的顺序一直，比如在thread_1 thread_2中都是condition1在前condition2在后，所以在mian里调用的顺序也是thread_1在前thread_2在后，否则会发生死锁。　　public class printInturn {

private static int cnt=0;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();


        Thread thread_1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (cnt<10) {
                    
                    lock.lock();
                    try {
                        System.out.println("Thread_1    "+cnt);
　　　　　　　　　　　　　　 cnt++;

                        condition1.await();
                        condition2.signal();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });

        Thread thread_2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (cnt<10) {
                    
                    lock.lock();
                    try {
                        System.out.println("Thread_2    "+cnt);
　　　　　　　　　　　　　　cnt++;
                        condition1.signal();
                        condition2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });
        thread_1.start();
        thread_2.start();

    }

}

转载于:https://www.cnblogs.com/AshOfTime/p/10791842.html