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

最新推荐文章于 2020-06-18 10:53:15 发布
最新推荐文章于 2020-06-18 10:53:15 发布
阅读量166 收藏
点赞数 1
分类专栏： 高并发

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.csdn.net/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();
		
		
		
		
		
		
		
		
	}
}

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

rosemarysmile
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（四）并发工具类ReadWriteLock（读写锁）与StampedLock（读写锁优化）
Devil_B的博客
07-04 447
ReadWriteLock（读写锁）与StampedLock（读写锁优化）ReadWriteLock读写锁降级StampedLock乐观读 ReadWriteLock 针对读多写少这种并发场景，Java SDK 并发包提供了读写锁——ReadWriteLock，其目的在于分场景优化性能，提升易用性。 读写锁都遵守以下三条基本原则： 允许多个线程同时读共享变量； 只允许一个线程写共享变量； 如果一个写线程正在执行写操作，此时禁止读线程读共享变量。 读写锁类似于 ReentrantLock，也支持公平模式和
JUC并发编程（java.util .concurrent工具包）详解与实例演示
BaiKnow的博客
02-03 1593
JUC 并发编程 作者：pox21s 概述 在Java中，线程部分是一个重点，本篇文章说的是关于线程并发编程。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，从JDK 1.5开始出现。 1.基本概念 1.1 进程和线程 1.1.1 定义 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个基本单位。 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥
并发编程--Concurrent-工具类介绍
alibb20000的博客
11-20 252
并发编程--Concurrent-工具类介绍 并发编程--Concurrent-工具类介绍 CountDownLatch CylicBarrier Semaphore Condition 对象监视器下个篇幅引入 Callable 不单独说明 Demo中会使用 Future Java 5 添加了一个新的包到 Java 平台，java.util.conc...
concurrent.util工具类
奔波在代码路上
11-28 293
concurrent.util工具类 1、CountDownLatch 用于监听某些初始化操作，等初始化完成后再通知主线程继续工作。在并发编程的场景中，最常见的一个case是某个任务的执行，需要等到多个线程都执行完毕之后才可以进行，CountDownLatch可以很好解决这个问题。 final CountDownLatch countDown = new CountDown...
Concurrent---工具类(CountDownLatch、CycliBarrier、Semaphore)
01-26 375
CountDownLatch 介绍 java.util.concurrnet.CountDownLatch 是一个同步辅助类，利用它可以实现类似计数器的功能，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用一个给定的计数来初始化CountDownLatch，通过调用countDown()方法使计数减1，在计数达到0之前，被await()阻塞的线程会一直阻塞，之后，会释放所...
Concurrent常用工具类的使用(CyclicBarrier/CountDownLatch/Callable)
zxiang248的专栏
04-11 363
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.util.concurrent介绍(重要).pdf
03-14
- `ReentrantLock`：可重入锁，实现 `Lock` 接口，具有公平和非公平模式。 - `ReadWriteLock` 和 `ReentrantReadWriteLock`：读写锁，允许多个读取者同时访问，但限制写入者的数量。 6. **Future 和 Callable**：...
java.util.concurrent.*（并发工具类） 学习笔记
suyongcai1234的博客
06-18 563
java.util.concurrent.*(并发工具包) 学习笔记 1.并发工具类的作用 1. 为了并发安全； 2. 方便线程管理，避免大量锁的创建和销毁，提高运行效率； 3. 线程间协作 2. 线程池 线程池的重要性 1. 反复创建线程与销毁大量的线程开销大 2. 过多的线程会占用太多的时间 线程池的好处 1. 合理利用CPU和内存 2. 方便统一管理线程 3. 避免锁的创建和销毁，加快响应速度 线程池的构造函数重要参数 1. corePoolSize : 核心线程池线程数量
深思写锁工具
10-04
最新582写锁，全国版，支持GTJ2018，带16G模块等。写锁可以两种选择
写锁工具、广联达ET199最新7e be写锁全国全专业写锁工具
02-25
广联达ET199最新7e be写锁全国全专业写锁工具,软件下载广联达G+软件 直接使用。
美萍写锁工具
09-20
2013 2014都可以进行写狗 欢迎大家下载
广联达写锁工具
11-10
深思写锁工具支持GTJ2018云计价等等 。
深思通用写锁工具
12-01
广联达深思S4写锁工具，支持532.570.580.582.585.586.588 只有写锁工具
java.concurrent内置工具类
gejiangbo222的专栏
06-10 145
工具 1.CountDownLatch 　CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。 　　CountDownLatch类只提供了一个构造器： 1 publicCoun...
ConCurrent包下工具类-CyclicBarrier
li_gameover的专栏
10-01 417
需要一组线程同时达到某个条件后一起啊开始执行。 类似的场景：一个线程代表一个跑步运动员，当所有的运动员都准备好了之后才一起出发。只要有一个没有准备好，大家都继续等待。 package com.lihuan.concurrentUtil;import java.util.Random; import java.util.concurrent.CyclicBarrier; import java
util.concurrent下的常用工具类（七）
shuduti的博客
11-05 237
CountDownLacth的使用 CountDownLacth经常用于监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作（一个线程等待其他所有线程的通知后再执行）。 public class UseCountDownLatch { public static void main(String[] args) { //这里的初始化参数表示只要countDown()方法被线程调用两次...
Concurrent.util常用的工具类
汤小萌的博客
05-04 364
Concurrent.util常用的工具类 1.CountDownLatch使用: 他经常用于监听某些初始化操作,等初始化执行完毕之后,通知主线程继续工作: 白老师讲zookeeper的例子,调用服务,只有等所有的初始化操作都完成之后,才可以进行使用功能 代码案例: public class UseCountDownLatch { public stat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值