concurrent-2-同步控制

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量215 收藏
点赞数
分类专栏： concurrent 文章标签： thread concurrent java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_ygy/article/details/72774324
版权

重入锁 ReentrantLock

重入锁示例
     lock ： 获取锁资源
     unLock ： 释放锁资源

//重入锁示例
public class TestReentrantLock {

    public static ReentrantLock lock=new ReentrantLock();  //重入锁

    public static  int count = 0 ;

    public static void main(String[] args) {

        for (int i = 0 ; i < 3 ; i++ ) {
           Thread thread = new Thread(
                    ()->{
                        while (true) {
                            lock.lock();  //获取锁
                            count++ ;
                            if (count > 1000000) {
                                break;
                            }
                            System.out.println(Thread.currentThread().getName() + "  ----"+ count);
                            lock.unlock();  //释放锁
                        }
                    }
            ,"thread--" + i);
           thread.start();
        }
    }
}
//输出
thread--2  ----999996
thread--2  ----999997
thread--2  ----999998
thread--2  ----999999
thread--2  ----1000000
中断响应
     lockInterruptibly ： 如果线程中断，停止对锁的等待
     isHeldByCurrentThread ： 判断当前线程是否含有该锁

//中断响应示例
public class TestReentrantLock {

    public static ReentrantLock lock1=new ReentrantLock();
    public static ReentrantLock lock2=new ReentrantLock();

    public static int count=0;

    public static void main(String[] args) {
        Thread thread=null;
        for (int i=1; i < 3; i++) {
           thread=new Thread(
                    () -> {
                            try {
                                if (Thread.currentThread().getName().equals("thread--1")) {
                                    lock1.lockInterruptibly();  //获取锁 1
                                    System.out.println(Thread.currentThread().getName() +  " lock1 lock ");
                                    try {
                                        Thread.sleep(5000);
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                    lock2.lockInterruptibly();//获取锁 2
                                    System.out.println(Thread.currentThread().getName() +  " lock2 lock ");
                                } else {
                                    lock2.lockInterruptibly();  //获取锁 2
                                    System.out.println(Thread.currentThread().getName() +  " lock2 lock ");
                                    try {
                                        Thread.sleep(5000);
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                    lock1.lockInterruptibly();//获取锁 1
                                    System.out.println(Thread.currentThread().getName() +  " lock1 lock ");
                                }
                                count++;
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } finally {
                                System.out.println(Thread.currentThread().getName() + "  ----" + count);
                                if (lock1.isHeldByCurrentThread()) {
                                    lock1.unlock(); //释放锁
                                    System.out.println(Thread.currentThread().getName() + " lock1 unlock ");
                                }
                                if (lock2.isHeldByCurrentThread()) {
                                    lock2.unlock(); //释放锁
                                    System.out.println(Thread.currentThread().getName() + " lock2 unlock ");

                                }
                            }

                        }
                    , "thread--" + i);
            thread.start();
        }
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
        thread.interrupt();  //中断线程2
        //输出
        thread--2 lock2 lock 
    thread--1 lock1 lock 
    0
    thread--2  ----0
    thread--2 lock2 unlock 
    thread--1 lock2 lock 
    thread--1  ----1
    thread--1 lock1 unlock 
    thread--1 lock2 unlock 
    java.lang.InterruptedException
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
        at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
        at com.mybatis.datasources.common.concurrent.TestReentrantLock.lambda$main$0(TestReentrantLock.java:40)
        at java.lang.Thread.run(Thread.java:745)
限时等待
    // 限时等待 在指定时间未获得锁资源后不再等待。
    lock.tryLock(5, TimeUnit.SECONDS) // 5秒后不再等待

 public static ReentrantLock lock=new ReentrantLock();

    // 限时等待 在指定时间未获得锁资源后不再等待。
    public static void main(String[] args) {
        for (int i=1; i < 3; i++) {
            new Thread(
                    () -> {
                        try {
                            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                                System.out.println(Thread.currentThread().getName() + "  get lock success ");
                                Thread.sleep(3);
                                lock.unlock();
                            } else {
                                System.out.println(Thread.currentThread().getName() + "  get lock fail ");
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    , "thread --" + i).start();
        }
    }
    //输出
    thread --2  get lock success 
    thread --1  get lock success
公平锁
    //公平锁，获取cpu执行权的几率相同

  public static ReentrantLock fairLock=new ReentrantLock(true);

    public static void main(String[] args) {
        for(int i = 1 ; i< 3 ; i++) {
            Thread thread=new Thread(
                    () -> {
                        while (true) {
                            fairLock.lock();
                            System.out.println(Thread.currentThread().getName() + " is getLocked");
                            fairLock.unlock();
                        }
                    }
                    , "thread -- " + i);
            thread.start();
        }
    }
    //输出
    thread -- 2 is getLocked
    thread -- 1 is getLocked
    thread -- 2 is getLocked
    thread -- 1 is getLocked
    thread -- 2 is getLocked
    thread -- 1 is getLocked

条件condition

        ReentrantLock配合使用
    //await :挂起线程等待，释放锁资源
    //signal ： 唤醒线程

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

    public static void main(String[] args) {
        Thread thread=new Thread(
                ()->{
                    lock.lock();
                    try {
                        System.out.println(Thread.currentThread().getName() +" is wait ");
                        condition.await();  //释放锁资源
                    } catch (InterruptedException e) {
                    }
                    System.out.println(Thread.currentThread().getName() +" is notify and end ");
                    lock.unlock();
                }
        ," thread -- 1");
        thread.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        condition.signal();  //叫醒等待线程。
        lock.unlock();
    }
    //输出
     thread -- 1 is wait 
     thread -- 1 is notify and end

Semaphore信号量

     //信号量
    //可以控制同时执行的线程数量
    //semaphore.acquire();   计数
    //semaphore.release();  释放线程

    public static Semaphore semaphore=new Semaphore(5);

    public static void main(String[] args) {

        ExecutorService executorService=Executors.newFixedThreadPool(20);

        for(int i = 0 ; i <20 ; i ++) {
            executorService.submit(
                    ()->{
                        try {
                            semaphore.acquire();
                            Thread.sleep(2000);
                            System.out.println(Thread.currentThread().getId() +" is end");
                            semaphore.release();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            );
        }
        executorService.shutdown();
    }
}
//输出   每次都是五个线程执行
13 is end
11 is end
14 is end
15 is end
12 is end
20 is end
16 is end
17 is end
18 is end
19 is end
22 is end
25 is end
21 is end
24 is end
23 is end
29 is end
26 is end
30 is end
28 is end
27 is end

ReentantReadWriteLock 读写锁

        //读写锁
        //读写：会互相阻塞
        //写写：会互相阻塞
        //读读：不会阻塞

 public static Lock lock = new ReentrantLock();
    public static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

      public static Lock readLock = reentrantReadWriteLock.readLock();  //读锁

      public static Lock writeLock = reentrantReadWriteLock.writeLock(); //写锁

      public static int count ;

    public static int read(Lock lock) {
        lock.lock();
        try {
            Thread.sleep(1000);
            System.out.println(System.currentTimeMillis() + " read " + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        return  count ;
    }

    public static void write(Lock lock,int count) {
        lock.lock();
        try {
            Thread.sleep(500);
            System.out.println(System.currentTimeMillis() + "  write " + count);
            TestReadWriteLock.count = count;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        for(int i = 0 ; i < 20 ;i ++) {
            new Thread(
                    ()-> read(lock)   //20个线程进行读的操作
                    //()-> read(readLock)
            ).start();
        }
        for (int i = 0; i< 2; i ++) {
            new Thread(          //2个线程进行写的操作
                    ()-> write(lock,new Random().nextInt(10))
                    //()-> write(writeLock,new Random().nextInt(10))
            ).start();
        }
    }
    //输出1   重入锁
    //        1495871944846 read 0
    //        1495871945847 read 0
    //        1495871946847 read 0
    //        1495871947847 read 0
    //        1495871948848 read 0
    //        1495871949848 read 0
    //        1495871950848 read 0
    //        1495871951848 read 0
    //        1495871952848 read 0
    //        1495871953848 read 0
    //        1495871954848 read 0
    //        1495871955848 read 0
    //        1495871956848 read 0
    //        1495871957848 read 0
    //        1495871958848 read 0
    //        1495871959848 read 0
    //        1495871960848 read 0
    //        1495871961848 read 0
    //        1495871962848 read 0
    //        1495871963849 read 0
    //        1495871964349  write 0
    //        1495871964849  write 9

    //输出2   读写锁
    //        1495871787331 read 0
    //        1495871787332 read 0
    //        1495871787333 read 0
    //        1495871787336 read 0
    //        1495871787342 read 0
    //        1495871787345 read 0
    //        1495871787352 read 0
    //        1495871787352 read 0
    //        1495871787352 read 0
    //        1495871787352 read 0
    //        1495871787352 read 0
    //        1495871787854  write 6
    //        1495871788855 read 6
    //        1495871788855 read 6
    //        1495871788855 read 6
    //        1495871788855 read 6
    //        1495871788855 read 6
    //        1495871788855 read 6
    //        1495871789356  write 3
    //        1495871790356 read 3
    //        1495871790356 read 3
    //        1495871790356 read 3

CountDownLatch 倒计时器

    //倒计时器
    //控制多线程等待，指定数量线程完成后执行主线程
    countDownLatch.await();   //等待计数

    public static CountDownLatch countDownLatch=new CountDownLatch(10);

    public static void main(String[] args) {
        ExecutorService executorService=Executors.newFixedThreadPool(10);
        for(int i = 0 ; i < 10 ; i++ ) {
            executorService.submit(
                    ()->{
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                        }
                        System.out.println(" thread is end ");
                        countDownLatch.countDown();
                    }
            );
        }
        try {
            countDownLatch.await();  //等待计数器完成后执行
        } catch (InterruptedException e) {
        }
        System.out.println(" countDownLatch is end ");
        executorService.shutdown();
    }
    //输出
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //thread is end
    //countDownLatch is end

循环栅栏CyclicBarrier

      //循环栅栏
    //每达到指定的N个线程后执行栅栏中的任务
    cyclicBarrier.await();   //计数等待

    public static boolean flag = false ;

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier =   new CyclicBarrier(10,
                ()->{
                    if (flag) {
                        System.out.println( "thread is done");
                    }else{
                        System.out.println(" thread is coming");
                        flag = true;
                    }
                }
        );
        for(int i = 0 ; i < 10 ; i ++) {
            new Thread(
                    ()->{
                        try {
                            cyclicBarrier.await();   //计数等待
                            //do work
                            Thread.sleep(1000);
                            System.out.println(Thread.currentThread().getName() + " is running");
                            //cyclicBarrier.await();  //计数等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
            ," thread -- " + i).start();
        }
        //输出1  ：无任务注释
        //thread is coming
        //thread -- 0 is running
        //thread -- 9 is running
        //thread -- 1 is running
        //thread -- 2 is running
        //thread -- 8 is running
        //thread -- 4 is running
        //thread -- 5 is running
        //thread -- 3 is running
        //thread -- 7 is running
        //thread -- 6 is running
        //thread is done
        //输出2  注释第一个   cyclicBarrier.await();
        //thread -- 1 is running
        //thread -- 3 is running
        //thread -- 7 is running
        //thread -- 5 is running
        //thread -- 9 is running
        //thread -- 0 is running
        //thread -- 8 is running
        //thread -- 4 is running
        //thread -- 2 is running
        //thread -- 6 is running
        //thread is coming
        //输出3   注释第二个   cyclicBarrier.await();
        //thread is coming
        //thread -- 3 is running
        //thread -- 7 is running
        //thread -- 5 is running
        //thread -- 1 is running
        //thread -- 9 is running
        //thread -- 2 is running
        //thread -- 6 is running
        //thread -- 8 is running
        //thread -- 0 is running
        //thread -- 4 is running
    }

线程阻塞

    //  LockSupport
    //  LockSupport.park();  //阻塞线程  不会释放锁资源，会立刻中断响应
    //  LockSupport.unpark(thread1);  

    public static  Object object = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(
                ()->{
                    synchronized (object) {
                        System.out.println(Thread.currentThread().getName() + " is running");
                        LockSupport.park();  //阻塞线程  不会释放锁资源
                        System.out.println(Thread.currentThread().getName() + " is end");
                    }
                }
        ,"thread -- 1");
        Thread thread2 = new Thread(
                ()->{
                    synchronized (object) {
                        System.out.println(Thread.currentThread().getName() + " is running");
                        LockSupport.park();  //阻塞线程  不会释放锁资源
                        System.out.println(Thread.currentThread().getName() + " is end");
                    }
                }
        ," thread -- 2");
        thread1.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
        LockSupport.unpark(thread1);
        LockSupport.unpark(thread2);
    }
    //输出
    //thread -- 1 is running
    //thread -- 1 is end
    //thread -- 2 is running
    //thread -- 2 is end
Liberal_夜不黑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
concurrent-1.3.4.jar
05-21
并发控制：concurrent包提供了一些线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，可以在多线程环境下安全地对集合进行操作，而无需手动添加同步机制。 原子操作：concurrent包提供了一些原子...
concurrent-all-in-one.pdf
03-14
2. **同步机制** - `Synchronized`：关键字确保同一时间只有一个线程能访问特定代码块，防止数据不一致。 - `实例方法同步`：对实例方法应用synchronized，锁定对象实例。 - `静态方法同步`：对静态方法应用...
java.util.concurrent 同步器框架详解
weixin_30268071的博客
07-05 172
作者简介 善光，一个半年才打一次篮球的程序猿。一直从事 Java 化开发，目前负责物流压力平衡、千里眼和风暴眼 Java 化项目。 引言 一般的应用系统中，存在着大量的计算和大量的 I/O 处理，通过多线程可以让系统运行得更快。但在 Java 多线程编程中，会面临很多的难题，比如线程安全、上下文切换、死锁等问题。 线程安全 引用 《Java Concurrency in Practice》 的...
Java Concurrent--同步工具类
霍淇滨的博客
05-27 126
同步工具类图 闭锁相关：CountDownLatch 信号量相关：Semaphore 栅栏相关：CyclicBarrier 、Exchanger 线程池相关：Executors 什么是同步工具类 同步工具类可以是任何一种对象，只要它能够根据自身的状态来协调线...
concurrent包的同步器
weixin_34342905的博客
04-25 77
2019独角兽企业重金招聘Python工程师标准>>> ...
深度解析Java 同步框架(java.util.concurrent包下的同步类)
时间海绵
06-13 696
JDK1.5开始提供了程序级别的同步框架在java.util.concurrent包下，这些同步类基于一个基础类进行编写，下面我们将解读原作者的编程思想
Synchronized vs Concurrent Collections（并发集合VS同步集合）
u014308482的博客
11-10 4187
Synchronized vs Concurrent Collections不管是同步集合还是并发集合他们都支持线程安全，他们之间主要的区别体现在性能和可扩展性，还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现（比如：ConcurrentHashMap, CopyOnWriteArrayList, Cop
java-同步集合Concurrent Collections应用
热门推荐
心猿意碼
04-18 1万+
一、传统集合的缺陷 传统的集合，在并发访问的时候，是有问题的。如hashset、hashmap和arrayList，多个线程在对他们取数据、放数据的时候，是有问题的，因为他们是线程不安全的。由于没有控制并发，会导致数据的不一致，引起死循环。 为什么会引起死循环？拿HashMap来看，看一下HashMap的get函数的源代码: public V get(Object key){ i...
探索并发多线程编程：`Concurrent-MulThread-Demo`
gitblog_00005的博客
04-22 348
探索并发多线程编程：Concurrent-MulThread-Demo Concurrent-MulThread多线程并发编程学习的实用代码片段分享，手写线程池更新中~项目地址:https://gitcode.com/gh_mirrors/co/Concurrent-MulThread-Demo 在当今的高性能计算和实时应用中，并发多线程编程已经成为必不可少的技术之一。今天我们要介绍的是一个开源...
Java多线程 - 线程同步
honvin的博客
09-22 3942
线程同步，主要是应用在多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作。 例子： 上万人同时抢100张票 一个账号在两个银行同时取钱 现实生活中，并发情况很常见。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问，此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 排队的形成条件：队列 + 锁 由
java concurrent 包_Java并发---concurrent包
weixin_28727975的博客
02-16 969
一、包的结构层次其中包含了两个子包atomic和locks，另外字concurrent下的阻塞队列以及executor，这些就是concurrent包中的精华。而这些类的实现主要是依赖于volatile和CAS，从整体上看concurrent包的整体实现图如下：二、Lock和synchronized的比较锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源。在L...
poc-concurrent-api
07-03
2. 获取项目：克隆或下载`poc-concurrent-api`仓库至本地。 3. 进入项目目录：`cd poc-concurrent-api-master`。 4. 使用`pm2`启动：运行`pm2 start process.json`，这将依据`process.json`配置文件启动项目。 "poc...
backport-util-concurrent（2.2 /3.1）
08-14
《backport-util-concurrent：Java...无论是ReentrantLock的细粒度控制，还是Phaser的灵活同步，或是ScheduledThreadPool的定时任务管理，backport-util-concurrent都提供了丰富的工具集，让旧版Java也能焕发新的活力。
concurrent-1.3.4-sources.jar
11-13
2. **java.util.concurrent** 包：这个包是Java并发库的核心，包含了许多并发和线程池相关的类，如ExecutorService、ThreadPoolExecutor、Future和Callable等。ExecutorService是线程池的接口，通过它可以管理和控制...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 552
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 875
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 543
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 249
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 823
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值