ReentrantLock

最新推荐文章于 2022-09-14 13:45:07 发布
最新推荐文章于 2022-09-14 13:45:07 发布
阅读量191 收藏
点赞数
分类专栏： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011153869/article/details/54911737
版权 
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 一道经典的Java多线程编程题
 * Created by yuanyong on 17/2/7.
 * 问题描述
 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5,
 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15.
 接着再由线程1打印16,17,18,19,20....以此类推,
 直到打印到75. 程序的输出结果应该为:

 */
public class ThreadDemo2 {
     final Lock lock = new ReentrantLock();
     final Condition condition_1 = lock.newCondition();
     final Condition condition_2 = lock.newCondition();
     final Condition condition_3 = lock.newCondition();

    public static volatile int number = 0;

    class RunClass implements Runnable {
        ConcurrentLinkedQueue<Integer> stack;

        RunClass(Integer id, ConcurrentLinkedQueue<Integer> stack) {
            this.id = id;
            this.stack = stack;
        }

        private int id;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        private void wirte() {
            int i = 5;
            while (i > 0) {
                number++;
                System.out.println(Thread.currentThread().getName() + ":" + number);
                i--;
            }
        }

        @Override
        public void run() {
            switch (id) {
                case 1:
                    while (stack.size() > 0) {
                        //第一次
                        if (number == 0) {
                            lock.lock();
                            try {
                                wirte();
                                stack.poll();
                                condition_2.signal();
                            } finally {
                                lock.unlock();
                            }

                        } else {
                            lock.lock();
                            try {
                                condition_1.await();
                                if (stack.poll() == number) {
                                    wirte();
                                    condition_2.signal();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } finally {
                                lock.unlock();
                            }
                        }
                    }
                    break;
                case 2:
                    while (stack.size() > 0) {
                        lock.lock();
                        try {
                            condition_2.await();
                            if (stack.poll() == number) {
                                wirte();
                                condition_3.signal();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                    break;
                case 3:
                    while (stack.size() > 0) {
                        lock.lock();
                        try {
                            condition_3.await();
                            if (stack.poll() == number) {
                                wirte();
                                condition_1.signal();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                    break;
            }

        }
    }

    public static void main(String args[]) {
        ConcurrentLinkedQueue<Integer> stack1 = new ConcurrentLinkedQueue<Integer>();
        ConcurrentLinkedQueue<Integer> stack2 = new ConcurrentLinkedQueue<Integer>();
        ConcurrentLinkedQueue<Integer> stack3 = new ConcurrentLinkedQueue<Integer>();

        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        RunClass runClass = threadDemo2.new RunClass(1, stack1);
        RunClass runClass2 = threadDemo2.new RunClass(2, stack2);
        RunClass runClass3 = threadDemo2.new RunClass(3, stack3);

        Thread thread1 = new Thread(runClass, "线程1");
        Thread thread2 = new Thread(runClass2, "线程2");
        Thread thread3 = new Thread(runClass3, "线程3");


        int n_1 = 0;
        int n_2 = 5;
        int n_3 = 10;
        for (int n = 0; n < 5; n++) {
            stack1.add(n_1);
            stack2.add(n_2);
            stack3.add(n_3);
            n_1 += 15;
            n_2 += 15;
            n_3 += 15;
        }

        thread3.start();
        thread2.start();
        thread1.start();

    }


}

实例2
线程屏障

CountDownLatch单词使用

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 一道经典的Java多线程编程题
 * Created by yuanyong on 17/2/7.
 * 问题描述
 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5,
 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15.
 接着再由线程1打印16,17,18,19,20....以此类推,
 直到打印到75. 程序的输出结果应该为:

 */
public class ThreadDemo2 {
    ConcurrentLinkedQueue<Integer> stack1 = new ConcurrentLinkedQueue<Integer>();
    ConcurrentLinkedQueue<Integer> stack2 = new ConcurrentLinkedQueue<Integer>();
    ConcurrentLinkedQueue<Integer> stack3 = new ConcurrentLinkedQueue<Integer>();
     final CountDownLatch startGate=new CountDownLatch(1);
//     final CountDownLatch endGate=new CountDownLatch(3);
    final Lock lock = new ReentrantLock();
     final Condition condition_1 = lock.newCondition();
     final Condition condition_2 = lock.newCondition();
     final Condition condition_3 = lock.newCondition();

    public static volatile int number = 0;

    class RunClass2 implements Runnable{
        public void run() {
                //第一次
                if (number == 0) {
                    lock.lock();
                    try {
                        wirte();
                        stack1.poll();
                        condition_2.signal();
                    } finally {
                        lock.unlock();
                    }

                }
        }
    }


    private void wirte() {
        int i = 5;
        while (i > 0) {
            number++;
            System.out.println(Thread.currentThread().getName() + ":" + number);
            i--;
        }
    }

    class RunClass implements Runnable {
        ConcurrentLinkedQueue<Integer> stack;

        RunClass(Integer id, ConcurrentLinkedQueue<Integer> stack) {
            this.id = id;
            this.stack = stack;
        }

        private int id;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }



        @Override
        public void run() {
//            endGate.countDown();
//            System.out.println(endGate.getCount());
            try {
                startGate.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("switch--------");
            switch (id) {
                case 1:
                    while (stack.size() > 0) {
                            lock.lock();
                            try {
                                condition_1.await();
                                if (stack.poll() == number) {
                                    wirte();
                                    condition_2.signal();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } finally {
                                lock.unlock();
                            }
                    }
                    break;
                case 2:
                    while (stack.size() > 0) {
                        lock.lock();
                        try {
                            condition_2.await();
                            if (stack.poll() == number) {
                                wirte();
                                condition_3.signal();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                    break;
                case 3:
                    while (stack.size() > 0) {
                        lock.lock();
                        try {
                            condition_3.await();
                            if (stack.poll() == number) {
                                wirte();
                                condition_1.signal();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                    break;
            }



        }

        public ConcurrentLinkedQueue<Integer> getStack() {
            return stack;
        }

        public void setStack(ConcurrentLinkedQueue<Integer> stack) {
            this.stack = stack;
        }
    }

    public static void main(String args[]) throws BrokenBarrierException, InterruptedException {


        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        RunClass runClass = threadDemo2.new RunClass(1, threadDemo2.stack1);
        RunClass runClass2 = threadDemo2.new RunClass(2, threadDemo2.stack2);
        RunClass runClass3 = threadDemo2.new RunClass(3, threadDemo2.stack3);

        Thread thread1 = new Thread(runClass, "线程1");
        Thread thread2 = new Thread(runClass2, "线程2");
        Thread thread3 = new Thread(runClass3, "线程3");


        int n_1 = 0;
        int n_2 = 5;
        int n_3 = 10;
        for (int n = 0; n < 5; n++) {
            threadDemo2.stack1.add(n_1);
            threadDemo2.stack2.add(n_2);
            threadDemo2.stack3.add(n_3);
            n_1 += 15;
            n_2 += 15;
            n_3 += 15;
        }

//        threadDemo2.endGate.wait();


        thread1.start();
        thread2.start();
        thread3.start();


        Thread.sleep(3000);
        threadDemo2.startGate.countDown();
        new Thread(threadDemo2.new RunClass2()).start();
    }


}

CyclicBarrier可以重复使用对应博文地址：
http://blog.csdn.net/shihuacai/article/details/8856407

千里之行_始于足下
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用CountDownLatch启动和停止线程
u011153869的专栏
06-20 1639
package File; import java.util.concurrent.CountDownLatch; public class Indexer { Indexer(){}; public long timeTasks(int nThreads,final Runnable stak) throws InterruptedException{ final CountDow
ReentrantLock 锁详解
热门推荐
程序猿进阶
12-07 6万+
ReentrantLock 锁详解 ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantL
reentrantLock
星坠竹空
09-14 424
重入的概念是什么，实现原理是什么？公平锁和非公平锁区别是什么，体现在哪些地方？没有竞争到锁的线程怎么实现等待，释放锁时又是怎么被唤醒的？发现没有是不是跟synchronized代码结构差不多，只是多了一个lock和unlock的过程。我们先画个图来对比一下synchronized和lock的数据结构：这就是学技术特别有趣的地方，你看多了感觉很多高大上的技术底层设计实际都差不多。ReentrantLock默认是非公平锁。
ReentrantLock实现原理详解
08-31
《ReentrantLock实现原理详解》 ReentrantLock作为Java并发编程中的重要工具，相较于内置关键字`synchronized`，它提供了更灵活、更强大的锁控制能力。本文将深入探讨ReentrantLock的实现原理，包括其与`...
ReentrantLock解析
08-08
《ReentrantLock深度解析》 在Java并发编程中，ReentrantLock是JDK提供的一个可重入互斥锁，它是java.util.concurrent.locks包下的核心类。与synchronized关键字相比，ReentrantLock提供了更高的灵活性，如尝试加锁...
使用ReentrantLock和Lambda表达式让同步更
11-22
在高级并发编程中，`ReentrantLock`是一个强大的工具，相较于内置的`synchronized`关键字，它提供了更多的灵活性和控制。本篇文章将深入探讨`ReentrantLock`的使用以及如何结合Lambda表达式来优化同步代码。 `...
java ReentrantLock详解
08-26
Java ReentrantLock 详解 Java ReentrantLock 是 Java 1.5 中引入的锁机制，相比于传统的 synchronized 锁，它提供了更加灵活和强大的功能。ReentrantLock 是一种可重入锁，意味着同一个线程可以多次获得锁，而不会...
教你完全理解ReentrantLock重入锁
12-11
1. ReentrantLock的介绍 ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞。在java...
RecursiveTask
u011153869的专栏
02-10 3604
多线程并行计算 /** * Created by yuanyong on 17/2/8. */ import java.util.concurrent.ForkJoinPool; import java.util.concurrent.Future; import java.util.concurrent.RecursiveTask; public class CountTask ext
java 线程超时时间
u011153869的专栏
07-07 600
public static void main(String[] args) { String failReason = null; Future f=new FutureTask(new Callable() { @Override public Object call() throws Exception { // TODO Auto-generated met
Semaphore
u011153869的专栏
06-24 355
一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可
生产者消费者模式
u011153869的专栏
02-10 260
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.locks.Condition; import java.util.concu
Exchanger线程拷贝
u011153869的专栏
02-10 236
import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.concurrent.Exchanger; /** * Created by yuanyong on 17/2/8. */ public class ThreadLocalTest { public
OGSM绩效管理培训材料双份资料.pptx
07-12
OGSM绩效管理培训材料双份资料.pptx
CAD机械设计赛项单选题样题.docx
07-12
CAD机械设计赛项单选题样题
100款古风PPT (79).pptx
最新发布
07-12
【ppt素材】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
搭建zookeeper
07-12
搭建zookeeper

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值