9.concurrent.util包2个工具类以及重入锁，读写锁

最新推荐文章于 2025-05-28 09:11:50 发布
最新推荐文章于 2025-05-28 09:11:50 发布
阅读量198 收藏
点赞数 1
分类专栏： java
本文深入探讨了Java并发编程中的核心工具，包括CountDownLatch、CyclicBarrier、Semaphore、ReentrantLock和读写锁的使用方法及场景，通过实例代码展示了如何控制线程间的同步与通信。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.常用工具类

在这里插入图片描述

(1)countDownLatch

例子：

public class UseCountDownLatch {

    public static void main(String[] args) {

        CountDownLatch countDown = new CountDownLatch(2);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
         try {
             System.out.println("进入线程t1,等待其他线程处理完成...");
             countDown.await();
             System.out.println("t1线程继续执行");
         }catch (InterruptedException e){
             e.printStackTrace();

         }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t2线程初始化操作...");
                   Thread.sleep(3000);
                    System.out.println("t1线程初始化完毕，通知t1线程继续执行...");
                    countDown.countDown();
                }catch (InterruptedException e){
                    e.printStackTrace();

                }
            }
        }, "t2");


        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t3线程初始化操作...");
                    Thread.sleep(4000);
                    System.out.println("t3线程初始化完毕，通知t1线程继续执行...");
                    countDown.countDown();
                }catch (InterruptedException e){
                    e.printStackTrace();

                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：
进入线程t1,等待其他线程处理完成…
t3线程初始化操作…
t2线程初始化操作…
t1线程初始化完毕，通知t1线程继续执行…
t3线程初始化完毕，通知t1线程继续执行…
t1线程继续执行

CountDownLatch countDown = new CountDownLatch(2);中的2表示conutdown调用几次，
t2,t3线程调用完之后，t1线程才继续执行

2.cyclicBarrier使用

在这里插入图片描述

例子：

public class UseCycliBarrier {

    static class Runner implements Runnable{
        private CyclicBarrier barrier;
        private String name;

        public Runner(CyclicBarrier barrier, String name) {
            this.barrier = barrier;
            this.name = name;
        }

        @Override
        public void run() {

             try {
                 Thread.sleep(1000*(new Random().nextInt(5)));
                 System.out.println(name+"准备OK。");
                  barrier.await();
             }catch (Exception e){
                 e.printStackTrace();
             }
            System.out.println(name+"GO!!");
        }
    }

    public static void main(String[] args) {

        CyclicBarrier ba = new CyclicBarrier(3);
        ExecutorService executor = Executors.newFixedThreadPool(3);
        executor.submit(new Thread(new Runner(ba,"zhangsan")));
        executor.submit(new Thread(new Runner(ba,"lisi")));
        executor.submit(new Thread(new Runner(ba,"wangwu")));
        executor.shutdown();

    }

}

运行结果：

lisi准备OK。
wangwu准备OK。
zhangsan准备OK。
zhangsanGO!!
lisiGO!!
wangwuGO!!
三个线程使用同一个CyclicBarrier ，三个线程都执行完了await之后，再同时一起往下执行。
应用场景：如多台机器同一个点开始去计算的时候。
conutdown针对一个线程，CyclicBarrier 针对多个线程

在这里插入图片描述
例子：

public class UseFuture implements Callable<String> {

    private  String para;

    public UseFuture (String para){
        this.para=para;
    }

    /**
     * 这里是真实的业务逻辑，其执行可能很慢
     * @return
     * @throws Exception
     */
    @Override
    public String call() throws Exception {
        //模拟执行耗时
        Thread.sleep(3000);
        String result=this.para+"处理完成";
        return result;
    }

    public static void main(String[] args) throws Exception {
        String queryStr="query";
//构造FutureTask,并且传入需要真正进行业务逻辑处理的类，该类一定是实现了Callable接口的类
        FutureTask<String> future = new FutureTask<>(new UseFuture(queryStr));
//创建一个固定线程的线程池且线程数为1
        ExecutorService executor = Executors.newFixedThreadPool(1);
//这里提交任务future,则开启线程执行RealData的call()方法执行

 //submit和execute的区别：第一点是submit可以传入实现callable接口的实例对象，
 //第二点是submit方法有返回值
        Future f = executor.submit(future);
//会立马返回null
        System.out.println("请求完毕");
        System.out.println(f.get());
/*
        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();

        }*/

        /*while (true){
            if(f.get()==null){
            System.out.println("当前任务执行完毕");
            break;
            }
        }*/
        //可以用 FutureTask<String> 的get去获取值
        //如果call方法没有执行完，则依然会进行等待
        System.out.println("数据："+future.get());

        executor.shutdown();

    }
}

Semaphore又称信号量，是操作系统中的一个概念，在Java并发编程中，信号量控制的是线程并发的数量。
public Semaphore(int permits)
其中参数permits就是允许同时运行的线程数目;

下面先看一个信号量实现单线程的例子，也就是permits=1:

public class Driver {
    // 控制线程的数目为1，也就是单线程
    private Semaphore semaphore = new Semaphore(1);

    public void driveCar() {
        try {
            // 从信号量中获取一个允许机会
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + " start at " + System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " stop at " + System.currentTimeMillis());
            // 释放允许，将占有的信号量归还
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Car extends Thread{
    private Driver driver;

    public Car(Driver driver) {
        super();
        this.driver = driver;
    }

    public void run() {
        driver.driveCar();
    }
}
public class Run {
    public static void main(String[] args) {
        Driver driver = new Driver();
        for (int i = 0; i < 5; i++) {
            (new Car(driver)).start();
        }
    }
}

输出结果:
Thread-0 start at 1546858676423
Thread-0 stop at 1546858677424
Thread-1 start at 1546858677424
Thread-1 stop at 1546858678424
Thread-2 start at 1546858678424
Thread-2 stop at 1546858679424
Thread-3 start at 1546858679424
Thread-3 stop at 1546858680425
Thread-4 start at 1546858680425
Thread-4 stop at 1546858681425

将信号量设为3，线程总数设为10
输出结果：

Thread-1 start at 1546858780808
Thread-2 start at 1546858780808
Thread-0 start at 1546858780808
Thread-2 stop at 1546858781808
Thread-0 stop at 1546858781808
Thread-1 stop at 1546858781808
Thread-4 start at 1546858781808
Thread-3 start at 1546858781808
Thread-6 start at 1546858781808
Thread-6 stop at 1546858782809
Thread-3 stop at 1546858782809
Thread-4 stop at 1546858782809
Thread-8 start at 1546858782809
Thread-5 start at 1546858782809
Thread-7 start at 1546858782809
Thread-8 stop at 1546858783810
Thread-7 stop at 1546858783810
Thread-5 stop at 1546858783810
Thread-9 start at 1546858783810
Thread-9 stop at 1546858784810

从结果上看，发现3个线程同时执行。但第四个线程要等前面有一个完成之后才能执行。

信用量也可以一次获取多个。或者释放多个 如：
semaphore.acquire(3); semaphore.release(3);
参照：https://blog.youkuaiyun.com/sinat_36246371/article/details/53872412
例子：

public class UseSemaphore {
    public static void main(String[] args) {
        //线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        //只能5个线程同时访问
       final Semaphore semp = new Semaphore(5);
       //模拟20个客户端访问
        for (int index = 0; index < 20; index++) {
            final int NO =index;
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    //获取许可
                    try {
                        semp.acquire();
                        System.out.println("Accessing:"+NO);
                        //模拟实际业务逻辑
                       // Thread.sleep((long) (Math.random()*10000));
                        Thread.sleep(1000);
                        //访问完后，释放
                        semp.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            };
            exec.execute(run);

        }

        try {
            Thread.sleep(10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //退出线程池
        exec.shutdown();
    }
}

场景：可以模仿最大可连接数，使性能更好的利用

锁

在这里插入图片描述

ReentrantLock（重入锁）
在这里插入图片描述
在这里插入图片描述
读写锁
在这里插入图片描述

实例：

public class UseCondition {

	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	
	public void method1(){
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
			Thread.sleep(3000);
			System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
			condition.await();	// Object wait
			System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
			Thread.sleep(3000);
			System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
			condition.signal();		//Object notify
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseCondition uc = new UseCondition();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				uc.method1();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				uc.method2();
			}
		}, "t2");
		t1.start();

		t2.start();
	}
	
	
	
}


public class UseManyCondition {

	private ReentrantLock lock = new ReentrantLock();
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	
	public void m1(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m2(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m3(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
			c2.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m4(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c1.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m5(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		
		final UseManyCondition umc = new UseManyCondition();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m1();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m2();
			}
		},"t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m3();
			}
		},"t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m4();
			}
		},"t4");
		Thread t5 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m5();
			}
		},"t5");
		
		t1.start();	// c1
		t2.start();	// c1
		t3.start();	// c2
		

		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		t4.start();	// c1
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t5.start();	// c2
		
	}
	
	
	
}

















//读写锁
public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
	private ReadLock readLock = rwLock.readLock();
	private WriteLock writeLock = rwLock.writeLock();
	
	public void read(){
		try {
			readLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t4");		
		
//		t1.start();
//		t2.start();
		
//		t1.start(); // R 
//		t3.start(); // W
		
		t3.start();
		t4.start();
		
		
		
		
		
		
		
		
	}
}

因为时间问题，后面的请自行百度

（四）并发工具类ReadWriteLock（读写锁）与StampedLock（读写锁优化）
Devil_B的博客
07-04 516
ReadWriteLock（读写锁）与StampedLock（读写锁优化）ReadWriteLock读写锁降级StampedLock乐观读 ReadWriteLock 针对读多写少这种并发场景，Java SDK 并发包提供了读写锁——ReadWriteLock，其目的在于分场景优化性能，提升易用性。 读写锁都遵守以下三条基本原则： 允许多个线程同时读共享变量； 只允许一个线程写共享变量； 如果一个写线程正在执行写操作，此时禁止读线程读共享变量。 读写锁类似于 ReentrantLock，也支持公平模式和
手撕Java系列--java.util.concurrent包详解
横竖撇折点
10-23 939
java.util.concurrent 包提供了丰富的高级同步工具，这些工具可以帮助开发者更有效地管理并发问题。通过合理选择和使用这些工具，可以显著提高多线程程序的性能和可靠性。后续我会用一系列文章详细介绍每一个工具的设计思路、实现原理和使用场景，帮助你在并发场景下解决更多问题。
并发编程--Concurrent-工具类介绍
alibb20000的博客
11-20 298
并发编程--Concurrent-工具类介绍 并发编程--Concurrent-工具类介绍 CountDownLatch CylicBarrier Semaphore Condition 对象监视器下个篇幅引入 Callable 不单独说明 Demo中会使用 Future Java 5 添加了一个新的包到 Java 平台，java.util.conc...
GLD网络锁6.0写锁工具：开启加密锁写锁操作新篇章
最新发布
gitblog_06748的博客
05-28 361
GLD网络锁6.0写锁工具：开启加密锁写锁操作新篇章 【下载地址】GLD网络锁6.0写锁工具 GLD网络锁6.0写锁工具是一款专为深思五代加密锁设计的实用工具，帮助用户轻松完成加密锁的写锁操作。该工具界面简洁，操作便捷，适合各类用户快速上手。使用前请确保设备支持深思五代加密锁，并备份重要数据以防意外丢失。无论是个人用户还...
concurrent.util工具类
奔波在代码路上
11-28 350
concurrent.util工具类 1、CountDownLatch 用于监听某些初始化操作，等初始化完成后再通知主线程继续工作。在并发编程的场景中，最常见的一个case是某个任务的执行，需要等到多个线程都执行完毕之后才可以进行，CountDownLatch可以很好解决这个问题。 final CountDownLatch countDown = new CountDown...
Concurrent---工具类(CountDownLatch、CycliBarrier、Semaphore)
01-26 411
CountDownLatch 介绍 java.util.concurrnet.CountDownLatch 是一个同步辅助类，利用它可以实现类似计数器的功能，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用一个给定的计数来初始化CountDownLatch，通过调用countDown()方法使计数减1，在计数达到0之前，被await()阻塞的线程会一直阻塞，之后，会释放所...
Concurrent常用工具类的使用(CyclicBarrier/CountDownLatch/Callable)
zxiang248的专栏
04-11 408
Concurrent.Util常用类CyclicBarrier假设有一个场景：每个线程代表一个运动员，当运动员都准备好才一起出发，只要有一个没准备好就大家都等待。public class UseCyclicBarrier { static class Runner implements Runnable{ private CyclicBarrier barrier;
atlassian-util-concurrent-0.0.12.jar.zip
07-17
`atlassian-util-concurrent-0.0.12.jar.zip`是这个库的压缩文件，包含了`atlassian-util-concurrent-0.0.12.jar`本身以及相关的许可证文件`atlassian-profiling-license.txt`。这个库是Atlassian为Java开发者提供的...
【Java并发工具类】：掌握java.util.concurrent包下的12个高级工具，提升开发效率
[【Java并发工具类】：掌握java.util.concurrent包下的12个高级工具，提升开发效率](https://codepumpkin.com/wp-content/uploads/2017/09/ConcurrentHashMap.jpg.webp) # 1. Java并发编程概述 在现代软件开发中，...
Java - JUC(java.util.concurrent)包详解，其下的锁、安全集合类、线程池相关、线程创建相关和线程辅助类、阻塞队列
m0_65228708的博客
12-09 2163
JUC是什么？ Java中线程有六个状态 JUC的结构 synchronized和JUC的Lock 　 reentrantLock 　 Condition 　 JUC下的读写锁ReentrantReadWriteLock 不安全的集合类和JUC的collections 　 list 不安全-CpoyOnWriteArrayList 　 set 不安全-CopyOnWriteArraySet 　 HashMap不安全-ConcurrentHashMap JUC的Callab
利用Java的`java.util.concurrent`包优化多线程性能
windowshht的博客
07-02 636
通过合理使用线程池、并发集合、原子类和锁机制等并发工具，我们可以有效地优化多线程性能，减少线程安全问题的发生。在Java的多线程编程中，性能优化是一个永恒的话题。由于线程池的大小是固定的，因此它只会创建10个线程来执行这些任务，而不是为每个任务都创建一个新的线程。线程池是JUC包中最重要的工具之一，它提供了一种限制和管理线程生命周期的机制，可以显著减少线程创建和销毁的开销，提高系统的响应速度。（简称JUC）包，它包含了一系列并发工具类、线程池、并发集合等，为开发者提供了高效、安全、易用的多线程编程工具。
深思写锁工具
10-04
最新582写锁，全国版，支持GTJ2018，带16G模块等。写锁可以两种选择
美萍写锁工具
09-20
2013 2014都可以进行写狗 欢迎大家下载
深思通用写锁工具
12-01
广联达深思S4写锁工具，支持532.570.580.582.585.586.588 只有写锁工具
cass9.0-9.2写锁工具（含ET199写底层工具）.zip
09-01
cass9.0-9.2写锁工具（含ET199写底层工具），可以写cass9.X软件，含etfs文件虚拟系统！欢迎大家下载体验。
广联达加密锁，写锁工具，可以自己升级加密锁。
06-23
广联达加密锁，写锁工具，可以自己升级加密锁。
java.concurrent内置工具类
gejiangbo222的专栏
06-10 190
工具 1.CountDownLatch 　CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。 　　CountDownLatch类只提供了一个构造器： 1 publicCoun...
ConCurrent包下工具类-CyclicBarrier
li_gameover的专栏
10-01 459
需要一组线程同时达到某个条件后一起啊开始执行。 类似的场景：一个线程代表一个跑步运动员，当所有的运动员都准备好了之后才一起出发。只要有一个没有准备好，大家都继续等待。 package com.lihuan.concurrentUtil;import java.util.Random; import java.util.concurrent.CyclicBarrier; import java
util.concurrent下的常用工具类（七）
shuduti的博客
11-05 274
CountDownLacth的使用 CountDownLacth经常用于监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作（一个线程等待其他所有线程的通知后再执行）。 public class UseCountDownLatch { public static void main(String[] args) { //这里的初始化参数表示只要countDown()方法被线程调用两次...
Java并发编程：java.util.concurrent工具包详解
这篇文档是关于Java并发编程中`java.util.concurrent`包的用户指南，涵盖了多种并发工具类和接口的使用方法。以下是该指南中涉及的重要知识点的详细解释： 1. **阻塞队列 BlockingQueue** - 阻塞队列是一种特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值