最近因为一个take阻塞一直占有当前获取的lock 导致奇怪的现象这里把自己的测试代码贴下免得下次犯错

最新推荐文章于 2024-04-16 21:29:54 发布

原创最新推荐文章于 2024-04-16 21:29:54 发布 · 742 阅读

本内容遵循CC 4.0 BY-SA版权协议

本文探讨了并发编程中的核心概念，包括ReentrantLock、Condition、BlockingQueue和ConcurrentControl，通过创建线程池来实现高效的任务调度与管理。重点介绍了如何利用这些组件进行同步控制、信号通知和任务排队，旨在提升程序的并发处理能力和资源利用率。

    public static void main(String[] args){
        try{
            final Lock lock = new ReentrantLock();
            final Condition cond = lock.newCondition();
            final BlockingQueue<Object> q = new LinkedBlockingQueue<Object>();
            final ConcurrentControl parent = new ConcurrentControl(new AtomicInteger(1));
            ExecutorService service = Executors.newCachedThreadPool();
            
            service.submit(new Runnable() {
                public void run() {
                    while(true)
                        parent.test(lock, q,cond);
                }
            });
            
            service.submit(new Runnable() {
                public void run() {
                    while(true)
                        parent.checkGetLock(lock,cond);
                }
            });
            
            service.submit(new Runnable() {
                public void run() {
                    while(true){
                        try {
                            Thread.currentThread().sleep(2000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        q.add(new Object());
                    }
                }
            });
        }finally{
            
        }
    }
    
    
    private void checkGetLock(Lock lock,Condition cond){
        lock.lock();
        try{
            System.out.println("获得锁了");
            cond.signal();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
    
    private void test(Lock lock,BlockingQueue<Object> q,Condition cond){
        lock.lock();
        try{
            q.take();//该阻塞方法会导致 lock一直占有 不释放 尽管 take 内部是 await的
            cond.await();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }