java juc新型锁

最新推荐文章于 2023-02-21 10:10:07 发布
最新推荐文章于 2023-02-21 10:10:07 发布
阅读量174 收藏
点赞数
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45577314/article/details/125429141
版权

ReentrantLock

ReentrantLock 该锁与 synchronized 的区别 synchronized是自动解锁 而ReentrantLock 是手动加锁解锁 lock.lock(); 加锁 lock.unlock();解锁

Lock lock = new ReentrantLock();

	void m1() {
		try {
			lock.lock(); //加锁
			for (int i = 0; i < 10; i++) {
				TimeUnit.SECONDS.sleep(1);

				System.out.println(i);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();//解锁
		}
	}

ReentrantLock 还具有尝试锁定功能 trylock trylock不管锁定与否都会继续执行 可以通过返回来判断是否已经锁定 也可以指定tryLock的时间

Lock lock = new ReentrantLock();

	void a() {
		/*
		boolean locked = lock.tryLock(); //尝试锁定   
		System.out.println("m2 ..." + locked);
		if(locked) lock.unlock();  //如果锁定就解锁
		*/
		boolean locked = false;
		
		try {
			locked = lock.tryLock(5, TimeUnit.SECONDS);//指定时间5秒没有竞争到就往下走
			System.out.println("m2 ..." + locked);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if(locked) lock.unlock();
		}
		
	}

ReentrantLock lockInterruptibly 可以被打断的加锁 interrupt可以打断lockInterruptibly 竞争到了也会被打断 竞争不到会停止等待
Lock lock = new ReentrantLock(true); 此时是开启公平锁 公平锁定义自己查

public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		//开启线程1一直执行
		Thread t1 = new Thread(()->{
			try {
				lock.lock();
				System.out.println("t1 start");
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
				System.out.println("t1 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t1.start();
		//线程而竞争
		Thread t2 = new Thread(()->{
			try {
				lock.lockInterruptibly(); //可以对interrupt()方法做出相应
				System.out.println("t2 start");
				TimeUnit.SECONDS.sleep(5);
				System.out.println("t2 end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!");
			} finally {
				lock.unlock();
			}
		});
		t2.start();
		
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//此时可以打断线程2的等待使其结束竞争
		t2.interrupt();
	}

CountDownLatch

CountDownLatch latch = new CountDownLatch(5); 指定数量
latch.countDown(); 数量减一
latch.await(); 等待的点
latch.await();在某一个点卡住 然后当CountDownLatch指定数量走完之后再往下执行
在创建CountDownLatch的时候指定数量 比如 5 然后每次执行
latch.countDown()就会减一
当然如下所示join也可以实现 但是join是所有线程执行结束才会往下执行，不如CountDownLatch灵活 因为你可以再一个线程中多次countDown

public static void main(String[] args) {
        usingJoin();
        usingCountDownLatch();
    }

    private static void usingCountDownLatch() {
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);

        for(int i=0; i<threads.length; i++) {
            threads[i] = new Thread(()->{
                int result = 0;
                for(int j=0; j<10000; j++) result += j;
                latch.countDown();
            });
        }

        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("end latch");
    }

    private static void usingJoin() {
        Thread[] threads = new Thread[100];

        for(int i=0; i<threads.length; i++) {
            threads[i] = new Thread(()->{
                int result = 0;
                for(int j=0; j<10000; j++) result += j;
            });
        }

        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }

        for (int i = 0; i < threads.length; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("end join");
    }

CyclicBarrier

如下代码很 设置一个值10 当下方循环执行barrier.await();10次之后才会执行，意思就是每10次执行放开一次没啥可说的哈哈哈隔

    public static void main(String[] args) {

        CyclicBarrier barrier = new CyclicBarrier(10, () -> System.out.println("满了"));

        for(int i=0; i<100; i++) {

            new Thread(()->{
                try {
                    barrier.await();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

Phaser

如下所示 这个比较麻烦首先说代码大致逻辑
5个参加婚礼的人 外加新郎新娘两人
婚礼进程分为 到达 => 吃饭 => 离开 => 洞房
前三个是所有人 东方是新郎新娘两人

知识关键点
Phaser 类的onAdvance方法
只有所有人都执行之后才会调用
该方法共有两个参数 第一个参数当前阶段 第二个参数 执行中arriveAndAwaitAdvance的数量 arriveAndDeregister不计入第二个参数数量phaser.register()这个方法也可以往上加
该方法返回true代表成功

大致执行过程创建一个类继承Phaser 然后创建实例
然后往里面家线程new Thread(new Person(“p” + i)).start();
下面逻辑自己看写不下去了哈哈哈隔

    static Random r = new Random();
    static MarriagePhaser phaser = new MarriagePhaser();

    static void milliSleep(int milli) {
        try {
            TimeUnit.MILLISECONDS.sleep(milli);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        phaser.bulkRegister(7);

        for(int i=0; i<5; i++) {

            new Thread(new Person("p" + i)).start();
        }

        new Thread(new Person("新郎")).start();
        new Thread(new Person("新娘")).start();

    }

    static class MarriagePhaser extends Phaser {
        @Override
        protected boolean onAdvance(int phase, int registeredParties) {

            switch (phase) {
                case 0:
                    System.out.println("所有人都到齐了！" + registeredParties);
                    System.out.println();
                    return false;
                case 1:
                    System.out.println("所有人都吃完了！" + registeredParties);
                    System.out.println();
                    return false;
                case 2:
                    System.out.println("所有人都离开了！" + registeredParties);
                    System.out.println();
                    return false;
                case 3:
                    System.out.println("婚礼结束！新郎新娘抱抱！" + registeredParties);
                    return true;
                default:
                    return true;
            }
        }
    }

    static class Person implements Runnable {
        String name;

        public Person(String name) {
            this.name = name;
        }

        public void arrive() {

            milliSleep(r.nextInt(1000));
            System.out.printf("%s 到达现场！\n", name);
            phaser.arriveAndAwaitAdvance();
        }

        public void eat() {
            milliSleep(r.nextInt(1000));
            System.out.printf("%s 吃完!\n", name);
            phaser.arriveAndAwaitAdvance();
        }

        public void leave() {
            milliSleep(r.nextInt(1000));
            System.out.printf("%s 离开！\n", name);


            phaser.arriveAndAwaitAdvance();
        }

        private void hug() {
            if(name.equals("新郎") || name.equals("新娘")) {
                milliSleep(r.nextInt(1000));
                System.out.printf("%s 洞房！\n", name);
                phaser.arriveAndAwaitAdvance();
            } else {
                phaser.arriveAndDeregister();
                //phaser.register()
            }
        }

        @Override
        public void run() {
            arrive();
            eat();
            leave();
            hug();

        }
    }

ReadWriteLock

读写锁 故名思意的东西
读写锁的概念其实就是共享锁和排他锁，读锁就是共享锁，写锁就是排他锁read()读一个数据，write()写一个数据
ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); 读写锁
readWriteLock.readLock(); 读锁
readWriteLock.writeLock(); 写锁

	static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static Lock readLock = readWriteLock.readLock();
    static Lock writeLock = readWriteLock.writeLock();
        public static void read(Lock lock) {
        try {
            lock.lock();
            Thread.sleep(1000);
            System.out.println("read over!");
            //模拟读取操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void write(Lock lock, int v) {
        try {
            lock.lock();
            Thread.sleep(1000);
            value = v;
            System.out.println("write over!");
            //模拟写操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
     public static void main(String[] args) {
        Runnable readR = ()-> read(readLock); //读操作
        Runnable writeR = ()->write(writeLock, new Random().nextInt()); //写操作

        for(int i=0; i<18; i++) new Thread(readR).start();
        for(int i=0; i<2; i++) new Thread(writeR).start();
    }

Semaphore

做限流用的 Semaphore s = new Semaphore(2, true); 最多限制2个 第二个参数true就是公平锁
几个关键方法
s.acquire() 阻塞方法获取 执行的时候 会减一如上 参数是2 执行一次则会减一 当减少到0的时候 再来一个线程获取不到了会阻塞
release（）方法当你用acquire()方法后执行完了执行release将会还原也就是数值加一 懂得都懂啊

public static void main(String[] args) {
        //Semaphore s = new Semaphore(2);
        Semaphore s = new Semaphore(2, true);
        //允许一个线程同时执行
        //Semaphore s = new Semaphore(1);

        new Thread(()->{
            try {
                s.acquire();

                System.out.println("T1 running...");
                Thread.sleep(200);
                System.out.println("T1 running...");

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                s.release();
            }
        }).start();

        new Thread(()->{
            try {
                s.acquire();

                System.out.println("T2 running...");
                Thread.sleep(200);
                System.out.println("T2 running...");

                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

Exchanger

Exchanger叫做交换器，俩人之间互相交换个数据用的。怎么交换呢，看这里，我第一个线程有一个成员变量叫s，然后exchanger.exchange(s)，第二个也是这样，t1线程名字叫T1，第二个线程名字叫T2。到最后，打印出来你会发现他们俩交换了一下。线程间通信的方式非常多，这只是其中一种，就是线程之间交换数据用的。

static Exchanger<String> exchanger = new Exchanger<>();

    public static void main(String[] args) {
        new Thread(()->{
            String s = "T1";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);

        }, "t1").start();

        new Thread(()->{
            String s = "T2";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);
        }, "t2").start();

    }
吾名隆冬二狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 338
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
JUC - Java锁
hxy1625309592的博客
03-02 100
1.1 公平锁、非公平锁 公平锁：非常公平，不能够插队，必须先来后到。 非公平锁： 非常不公平，可以插队（默认是非公平锁） 代码示例 // 公平锁 public ReentrantLock() { sync = new NonfairSync(); } // 非公平锁 public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } 1.2 可重入锁 1.2.1 可重入锁概念 同一线程外
java多线程--“锁”总览
节至
07-01 2265
根据锁的添加到Java中的时间，Java中的锁，可以分为"同步锁"和"JUC包中的锁"。 同步锁 　　即通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。Java 1.0版本中就已经支持同步锁了。 　　同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能
java juc之锁
weixin_43785508的博客
02-15 270
https://blog.csdn.net/weixin_43888181/article/details/116546374?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164493673916780271597016%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=164493673916780271597016&biz_.
juc3-java锁
u012222011的博客
03-09 230
8锁： 1.⼀个对象⾥⾯如果有多个synchronized⽅法，某⼀个时刻内，只要⼀个线程去调⽤其中 的⼀个synchronized⽅法了，其他的线程都只能等待，换句话说，某⼀个时刻内，只能有唯⼀⼀个线程去访问这些synchronized⽅法， 锁的是当前对象this，被锁定后，其他的线程都不能进⼊到当前对象的其他的 synchronized⽅法 2.加个普通⽅法后发现和同步锁⽆关 3.换成两个对象后，不是同⼀把锁了，情况⽴刻变化 4.全局锁 synchronized实现同步的基础： jav..
JUC线程锁框架
12-31
JUC，全称为Java Util Concurrency，是Java并发包的简称，包含了大量用于处理并发问题的类和接口，极大地简化了多线程环境下的编程。在这个深度解析JUC线程锁框架的主题中，我们将探讨其核心组件、设计模式以及如何...
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
22 尚硅谷Java JUC线程高级视频
08-07
教程视频：在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文...
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
juc aqs java
12-14
juc 的aqs介绍。
Java并发工具类（JUC）汇总（一）锁
qq_28187203的博客
08-02 463
文章目录一、锁1.锁分类2.无锁技术2.1 比较与交换（Compare And Swap）2.2 写入时复制 (Copy-on-write)2.3 线程本地存储 (Thread Local Storage, TLS)3.JUC中的锁3.1 AbstractQueuedSynchronizer(AQS)3.1.1 定义3.1.2 核心思想3.1.2.1 记录同步状态（state变量）3.1.2.2 记录当前持有锁的线程3.1.2.3 支持阻塞/唤醒操作3.1.2.4 阻塞队列（CLH）3.1.3 资源共享方式
java面试题-JUC锁
最新发布
qq_33129875的博客
02-21 501
JUC锁相关，Lock,AQS,ReentrantLock,ReentrantReadWriteLock等相关面试题
Java并发编程-ReentrantLock源码分析
aikuangchou2298的博客
04-17 185
一、前言 在分析了AbstractQueuedSynchronier源码后，接着分析ReentrantLock源码，其实在AbstractQueuedSynchronizer的分析中，已经提到过ReentrantLock，ReentrantLock表示下面具体分析ReentrantLock源码。 二、ReentrantLock数据结构 ReentrantLock的底层是...
Java并发编程—JUC的Lock锁
sanmi8276的博客
02-23 392
一、Lock （JUC锁） JUC 锁位于java.util.concurrent.locks包下，为锁和等待条件提供一个框架，它不同于内置同步和监视器。 CountDownLatch，CyclicBarrier 和 Semaphore 不在包中属于并发编程中的工具类，但也是通过 AQS（后面会讲） 来实现的。因此，我也将它们归纳到 JUC 锁中进行介绍。 1、Lock Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。 2、R...
JUC编程之锁详解
以梦为马，不负韶华
11-02 310
Juc简称是并发包的简写。在jdk1.5之后，并发包新增了Lock接口，以及很多Lock锁的实现类用来实现锁的功能，Lock锁提供了和Synchroized类似的功能，要手动加锁和释放锁。
juc并发工具包中各种锁 2020最新
乡村非主流2020的博客
06-05 195
​一.java中的锁 根据加入Java中的时间，Java中的锁，可以分为"同步锁"和"JUC包中的锁"。 同步锁 　　即通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。Java 1.0版本中就已经支持同步锁了。 　　同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能进行CPU调度，从而在CPU上执行；而没有获取到同步锁的线程，必须进行等待，直到获取到同步锁之
详解JUC之锁——概述（01）
腹黑大壁花
05-11 1620
前言在详解JUC之原子类使用及实现中，我介绍了一下JUC中的原子类的使用和实现，现在我就来介绍一下JUC的重磅武器——锁（Lock）同步锁在说JUC中的锁之前，得先说一下它们的前辈——同步锁，有对比才有伤害嘛~同步锁的概念是，不同的线程可以访问一个同步锁，但是在同一个时间点，这个同步锁只能被一个线程获取，而想要却得不到它的线程就必须等待了，直到获取到它才能继续运行。Java是通过synchroniz
JUC锁-锁的分类
oheg2010的博客
05-15 2353
锁的分类 悲观锁：在进入同步方法的时候都会获取当前同步锁对象，直到退出同步方法时才会释放同步锁对象。如果有线程A和线程B,同他们都会访问obj对象的同步方法。当线程A获取到obj对象的同步锁，在执行某些方法的时候，这时候线程B企图获取 obj对象的同步锁就会失败，这个时候必须等待，直到线程A释放掉 obj对象的同步锁，线程B才能执行obj的同步方法 java中的悲观锁是synchronized，A...
JUC包下各种锁使用详解
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-03 1661
相对之下公平锁由于是有序执行，所以相对非公平锁来说执行更慢，吞吐量更小一些。而非公平锁可以在特定场景下实现插队，所以很有可能出现某些线程被频繁插队而导致"线程饥饿"的情况。
Java JUC并发编程实例：守护线程与Synchronized锁
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值