设为首页 加入收藏

TOP

JDK并发包详细总结(二)
2018-06-09 10:07:58 】 浏览:907
Tags:JDK 发包 详细 总结

ot;);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        DeadLock deadLock1 = new DeadLock(1);
        DeadLock deadLock2 = new DeadLock(2);
        // 线程1, 线程2分别去获取lock1, lock2. 导致死锁
        Thread t1 = new Thread(deadLock1);
        Thread t2 = new Thread(deadLock2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        // 死锁检查, 触发中断
        DeadlockChecker.check();


    }
}


类似于 Object.wait()和Object.notify(), 需要与ReentrantLock结合使用.


具体API如下:


// await()方法会使当前线程等待,同时释放当前锁,当其他线程中使用signal()时或者signalAll()方法时,
    // 线程会重新获得锁并继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法很相似。
    void await() throws InterruptedException;
    // awaitUninterruptibly()方法与await()方法基本相同,但是它并不会再等待过程中响应中断。
    void awaitUninterruptibly();
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    // singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。
    // 这和Obejct.notify()方法很类似。
    void signal();
    void signalAll();


示例


public class ReenterLockCondition implements Runnable{


    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();


    @Override
    public void run() {
        try {
            lock.lock();
            condition.await();
            System.out.println("Thread is going on");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 注意放到finally中释放
            lock.unlock();
        }
    }


    public static void main(String[] args) throws InterruptedException {
        ReenterLockCondition t1 = new ReenterLockCondition();
        Thread tt = new Thread(t1);
        tt.start();
        Thread.sleep(2000);
        System.out.println("after sleep, signal!");
        // 通知线程tt继续执行. 唤醒同样需要重新获得锁
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}


Semaphore信号量


锁一般都是互斥排他的, 而信号量可以认为是一个共享锁,


允许N个线程同时进入临界区, 但是超出许可范围的只能等待.


如果N = 1, 则类似于lock.


具体API如下, 通过acquire获取信号量, 通过release释放


1    public void acquire()
2    public void acquireUninterruptibly()
3    public boolean tryAcquire()
4    public boolean tryAcquire(long timeout, TimeUnit unit)
5    public void release()


示例


模拟20个线程, 但是信号量只设置了5个许可.


因此线程是按序每2秒5个的打印job done.


public class SemapDemo implements Runnable{


    // 设置5个
JDK并发包详细总结(二) https://www.cppentry.com/bencandy.php?fid=54&id=170263

首页 上一页 1 2 3 4 5 6 7 下一页 尾页 2/8/8
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇Java高并发之线程池详解 下一篇Java高并发之无锁与Atomic源码分析