二、多线程(4)JUC并发包--tools--CountDownLatch/CyclicBarrier/Semaphore/Executors/Exchanger

最新推荐文章于 2021-04-04 16:26:00 发布

M_azed

最新推荐文章于 2021-04-04 16:26:00 发布

阅读量260

点赞数

分类专栏：多线程文章标签： JUC CountDownLatch CyclicBarrier Semaphore Exchanger

本文链接：https://blog.csdn.net/M_azed/article/details/92834212

版权

多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

主要包含了 CountDownLatch , CyclicBarrier , Semaphore , Executors , Exchanger 等

一.CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

1.原理:

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

2.主要方法:

public CountDownLatch(int count); //指定计数的次数，只能被设置1次
public void countDown();          //调用此方法则计数减1
public void await() throws InterruptedException   //调用此方法会一直阻塞当前线程，直到计时器的值为0，除非线程被中断。
Public Long getCount();           //得到当前的计数
Public boolean await(long timeout, TimeUnit unit) //调用此方法会一直阻塞当前线程，直到计时器的值为0，除非线程被中断或者计数器超时，返回false代表计数器超时。
From Object Inherited：
Clone、equals、hashCode、notify、notifyALL、wait等。

3.示例:

public class CountDownLatchDemo {  
    final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    public static void main(String[] args) throws InterruptedException {  
        CountDownLatch latch=new CountDownLatch(2);//两个工人的协作  
        Worker worker1=new Worker("zhang san", 5000, latch);  
        Worker worker2=new Worker("li si", 8000, latch);  
        worker1.start();//  
        worker2.start();//  
        latch.await();//等待所有工人完成工作  
        System.out.println("all work done at "+sdf.format(new Date()));  
    }  
      
      
    static class Worker extends Thread{  
        String workerName;   
        int workTime;  
        CountDownLatch latch;  
        public Worker(String workerName ,int workTime ,CountDownLatch latch){  
             this.workerName=workerName;  
             this.workTime=workTime;  
             this.latch=latch;  
        }  
        public void run(){  
            System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));  
            doWork();//工作了  
            System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));  
            latch.countDown();//工人完成工作，计数器减一  
  
        }  
          
        private void doWork(){  
            try {  
                Thread.sleep(workTime);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

4.使用场景:

开启多个线程分块下载一个大文件，每个线程只下载固定的一截，最后由另外一个线程来拼接所有的分段。
应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
确保一个计算不会执行，直到所需要的资源被初始化。

5.注意:

计数器count是闭锁需要等待的线程数量，只能被设置一次，且CountDownLatch没有提供任何机制去重新设置计数器count。

二.CyclicBarrier

并发编程辅助工具, CyclicBarrier 指 循环屏障, 它允许一组线程相互等待直到所有线程都到达一个公共的屏障点。

1.主要方法

//构造方法
public CyclicBarrier(int parties)    //参与线程的个数
public CyclicBarrier(int parties, Runnable barrierAction)    //最后一个到达线程要做的任务

//主要方法
public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

//其他
getParties()    //获取CyclicBarrier打开屏障的线程数量，也成为方数。
getNumberWaiting()    //获取正在CyclicBarrier上等待的线程数量。
isBroken()    //获取是否破损标志位broken的值
reset()    //使得CyclicBarrier回归初始状态

调用await方法的线程告诉CyclicBarrier自己已经到达同步点，然后当前线程被阻塞, 直到:

在CyclicBarrier上等待的线程数量达到parties，则所有线程被释放，继续执行。
当前线程被中断，则抛出InterruptedException异常，并停止等待，继续执行。
其他等待的线程被中断，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。
其他等待的线程超时，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。
其他线程调用CyclicBarrier.reset()方法，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

调用await(timeout,TimeUnit)方法的线程,在CyclicBarrier上进行限时的阻塞等待，直到:

在CyclicBarrier上等待的线程数量达到parties，则所有线程被释放，继续执行。
当前线程被中断，则抛出InterruptedException异常，并停止等待，继续执行。
当前线程等待超时，则抛出TimeoutException异常，并停止等待，继续执行。
其他等待的线程被中断，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。
其他等待的线程超时，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。
其他线程调用CyclicBarrier.reset()方法，则当前线程抛出BrokenBarrierException异常，并停止等待，继续执行。

调用isBroken()方法, 获取是否破损标志位broken的值，此值有以下几种情况：

CyclicBarrier初始化时，broken=false，表示屏障未破损。
如果正在等待的线程被中断，则broken=true，表示屏障破损。
如果正在等待的线程超时，则broken=true，表示屏障破损。
如果有线程调用CyclicBarrier.reset()方法，则broken=false，表示屏障回到未破损状态。

调用reset()方法, 使得CyclicBarrier回归初始状态，直观来看它做了两件事：

如果有正在等待的线程，则会抛出BrokenBarrierException异常，且这些线程停止等待，继续执行。
将是否破损标志位broken置为false。

2.示例

public class CyclicBarrierDemo {

    static class TaskThread extends Thread {
        
        CyclicBarrier barrier;
        
        public TaskThread(CyclicBarrier barrier) {
            this.barrier = barrier;
        }
        
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(getName() + " 到达栅栏 A");
                barrier.await();
                System.out.println(getName() + " 冲破栅栏 A");
                
                Thread.sleep(2000);
                System.out.println(getName() + " 到达栅栏 B");
                barrier.await();
                System.out.println(getName() + " 冲破栅栏 B");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        int threadNum = 5;
        CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
            
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 完成最后任务");
            }
        });
        
        for(int i = 0; i < threadNum; i++) {
            new TaskThread(barrier).start();
        }
    }
    
}

//结果
Thread-1 到达栅栏 A
Thread-3 到达栅栏 A
Thread-0 到达栅栏 A
Thread-4 到达栅栏 A
Thread-2 到达栅栏 A
Thread-2 完成最后任务
Thread-2 冲破栅栏 A
Thread-1 冲破栅栏 A
Thread-3 冲破栅栏 A
Thread-4 冲破栅栏 A
Thread-0 冲破栅栏 A
Thread-4 到达栅栏 B
Thread-0 到达栅栏 B
Thread-3 到达栅栏 B
Thread-2 到达栅栏 B
Thread-1 到达栅栏 B
Thread-1 完成最后任务
Thread-1 冲破栅栏 B
Thread-0 冲破栅栏 B
Thread-4 冲破栅栏 B
Thread-2 冲破栅栏 B
Thread-3 冲破栅栏 B

3.主要场景

可以用于多线程计算数据，最后合并计算结果的场景。

4.注意

CyclicBarrier和CountDownLatch的区别:

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置，可以使用多次，所以CyclicBarrier能够处理更为复杂的场景；

CyclicBarrier还提供了一些其他有用的方法，比如getNumberWaiting()方法可以获得CyclicBarrier阻塞的线程数量，isBroken()方法用来了解阻塞的线程是否被中断；

CountDownLatch允许一个或多个线程等待一组事件的产生，而CyclicBarrier用于等待其他线程运行到栅栏位置。

三.Semaphore

Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，保证合理的使用公共资源。

可以理解为, 工地只有2把锤子, 来了10个工人, 都去尝试拿锤子, 谁拿到锤子谁干活, 干完活就放回去让别人用

1.原理:

线程可以通过acquire()方法来获取信号量的许可，当信号量中没有可用的许可的时候，线程阻塞，直到有可用的许可为止。线程

可以通过release()方法释放它持有的信号量的许可。

2.主要方法

//构造方法
Semaphore(int permits)     // 创建具有给定的许可数和非公平的公平设置的 Semaphore。
Semaphore(int permits, boolean fair)    // 创建具有给定的许可数和给定的公平设置的 Semaphore。

//主要方法
void acquire()    // 从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

void acquire(int permits)    // 从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。

void acquireUninterruptibly()    // 从此信号量中获取许可，在有可用的许可前将其阻塞。

void acquireUninterruptibly(int permits)    // 从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞。

void release()    // 释放一个许可，将其返回给信号量。

void release(int permits)    // 释放给定数目的许可，将其返回到信号量。

//其他

// 返回此信号量中当前可用的许可数。
int availablePermits()
// 获取并返回立即可用的所有许可。
int drainPermits()
// 返回一个 collection，包含可能等待获取的线程。
protected Collection<Thread> getQueuedThreads()
// 返回正在等待获取的线程的估计数目。
int getQueueLength()
// 查询是否有线程正在等待获取。
boolean hasQueuedThreads()
// 如果此信号量的公平设置为 true，则返回 true。
boolean isFair()
// 根据指定的缩减量减小可用许可的数目。
protected void reducePermits(int reduction)
// 返回标识此信号量的字符串，以及信号量的状态。
String toString()
// 仅在调用时此信号量存在一个可用许可，才从信号量获取许可。
boolean tryAcquire()
// 仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。
boolean tryAcquire(int permits)
// 如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。
boolean tryAcquire(int permits, long timeout, TimeUnit unit)
// 如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。
boolean tryAcquire(long timeout, TimeUnit unit)

3.示例

public class SemaphoreTest {
    private static final int THREAD_COUNT = 10;
    
    private static ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
    // 创建5个许可，允许5个并发执行
    private static Semaphore s = new Semaphore(5);

    public static void main(String[] args) {
        //创建10个线程执行任务
        for (int i = 0; i < THREAD_COUNT; i++) {
            executorService.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        //同时只能有5个线程并发执行保存数据的任务
                        s.acquire();
                        System.out.println("线程" + Thread.currentThread().getName() + " 保存数据");
                        Thread.sleep(2000);
                        //5个线程保存完数据，释放许可，其他的线程才能获取许可，继续执行保存数据的任务
                        s.release();
                        System.out.println("线程" + Thread.currentThread().getName() + " 释放许可");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        executorService.shutdown();

    }

}

4.使用场景

单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”（这个特性很重要*），这可应用于死锁恢复的一些场合，另外Semaphore底层是CAS实现的，无锁，无线程上下文切换消耗，性能高。
限制访问公共资源的线程个数，如只有5个资源，那么同时执行的线程就只能是5个
控制多线程执行流程控制，如：主线程等待所有异步线程执行完毕后再执行、或者多个异步线程的执行顺序

public class SemaphoreTest2 {
private final Semaphore semaphoreA = new Semaphore(1);
private final Semaphore semaphoreB = new Semaphore(1);
private final Semaphore semaphoreC = new Semaphore(1);

public void start() throws InterruptedException {
    semaphoreB.acquire();//ABC线程启动之前 获取SemaphoreB的1个资源，保证线程A最先执行
    semaphoreC.acquire();//ABC线程启动之前 获取SemaphoreC的1个资源，保证线程A最先执行
    Thread a=new Thread(new Runnable(){
        @Override
        public void run() {
            while (true){
                try {
                    semaphoreA.acquire();
                    System.out.print("A");
                    semaphoreB.release();//之前说的特性：可以在ThreadA释放ThreadB的Semaphore资源， 下同
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    Thread b=new Thread(new Runnable(){
        @Override
        public void run() {
            while (true){
                try {
                    semaphoreB.acquire();
                    System.out.print("B");
                    semaphoreC.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    Thread c=new Thread(new Runnable(){
        @Override
        public void run() {
            while (true){
                try {
                    semaphoreC.acquire();
                    System.out.println("C");
                    semaphoreA.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    c.start();
    b.start();
    a.start();
}

public static final void main(String arsg[]) throws InterruptedException {
    SemaphoreTest2 semaphoreTest2=new SemaphoreTest2();
    semaphoreTest2.start();
}
}

5.注意

Semaphore通过自定义两种不同的同步器（FairSync&NonfairSync）提供了公平&非公平两种工作模式，两种模式下分别提供了限时/不限时、响应中断/不响应中断的获取资源的方法（限时获取总是及时响应中断的），而所有的释放资源的release操作是统一的。
"公平信号量"和"非公平信号量"的释放信号量的机制是一样的！不同的是它们获取信号量的机制：线程在尝试获取信号量许可时，对于公平信号量而言，如果当前线程不在CLH队列的头部，则排队等候；而对于非公平信号量而言，无论当前线程是不是在CLH队列的头部，它都会直接获取信号量。该差异具体的体现在，它们的tryAcquireShared()函数的实现不同
一个初始化为1的信号量，最多只能有一个可用的许可证，它可以作为互斥锁。这通常被称为二进制信号量，因为它只有两种状态：一个允许可用，或者零个允许可用。当以这种方式使用时，不同于其他java.util.concurrent.locks.Lock的实现，二进制信号量具有某种属性--“锁”可以由所有者以外的线程释放（因为信号量没有所有权的概念）。这在某些特定的上下文中很有用，例如死锁恢复。
通常，用于控制资源访问的信号量应该被初始化为公平的，以确保没有线程因访问资源而被耗尽。在将信号量用于其他类型的同步控制时，非公平排序的吞吐量优势往往超过公平模式

四.Executors

线程池工厂类, 它为我们创建线程池提供了一些工具方法。

详解:https://blog.csdn.net/M_azed/article/details/90702406#2.Executors%E5%B7%A5%E5%85%B7%E7%B1%BB

1.定长线程池

创建固定数目线程的线程池。

public static ExecutorService newFixedThreadPool(int nThreads)

2.缓存线程池

public static ExecutorService newCachedThreadPool()

创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

3.单例线程池

public static ExecutorService newSingleThreadExecutor()

创建一个单线程化的Executor。

4.周期执行线程池

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

五.Exchanger

java提供了一个同步工具类Exchanger，它允许在两个并发任务中交换数据。

xchanger允许在两个线程之间定义同步点，当两个线程到达同步点时可以交换数据，第一个线程的数据进入到第二个线程，第二个线程的数据进入第一个线程。先到达同步点的线程会等待另外一个线程，到达后完成数据交换。

示例:

生产者 -> 消费者

消费者到达excahnger先阻塞, 生产者生产10个商品后到达阻塞点, 进行交换, 交换完成后, 生产者 buffer为0, 消费者 buffer为10

类似于一个中转仓库一样

①生产者:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Exchanger;
 
public class Producer implements Runnable {
 
	private List<String> buffer;
 
	private final Exchanger<List<String>> exchanger;
 
	public Producer(Exchanger<List<String>> exchanger) {
		this.buffer = new ArrayList<String>();
		this.exchanger = exchanger;
	}
 
	@Override
	public void run() {
		int cycle = 1;
		for (int i = 0; i < 10; i++) {
			System.out.println("Producer cycle:" + cycle);
			
			//生产数据
			for (int j = 0; j < 10; j++) {
				String message = "message " + ((i * 10) + j);
				System.out.println("Producer Message:" + message);
				buffer.add(message);
			}
			
			//阻塞，等待另一个线程到达交换点(同步交换点)
			try {
				buffer = exchanger.exchange(buffer);
			} catch (Exception e) {
				e.printStackTrace();
			}
 
			System.out.println("Producer buffer  size:" + buffer.size());
			
			cycle++;
		}
 
	}
 
}

②消费者

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Exchanger;
 
public class Consumer implements Runnable {
 
	private List<String> buffer;
 
	private final Exchanger<List<String>> exchanger;
 
	public Consumer(Exchanger<List<String>> exchanger) {
		this.buffer = new ArrayList<String>();
		this.exchanger = exchanger;
	}
 
	
	@Override
	public void run() {
		int cycle = 1;
		for (int i = 0; i < 10; i++) {
			System.out.println("Consumer cycle:" + cycle);
 
			//阻塞，等待另一个线程到达交换点(同步交换点)
			try {
				buffer = exchanger.exchange(buffer);
			} catch (Exception e) {
				e.printStackTrace();
			}
 
			System.out.println("Consumer buffer  size:" + buffer.size());
			
			for (int j = 0; j < 10; j++) {
				String message = buffer.get(0);
				System.out.println("Consumer:"+message);
				buffer.remove(0);
			}
			cycle++;
		}
	}
 
}

③测试类

import java.util.List;
import java.util.concurrent.Exchanger;
 
public class Main {
 
	public static void main(String[] args) {
 
		Exchanger<List<String>> exchanger = new Exchanger<List<String>>();
		
		Producer producer = new Producer(exchanger);
		Consumer consumer = new Consumer(exchanger);
		
		Thread producerThread = new Thread(producer);
		Thread consumerThread = new Thread(consumer);
		producerThread.start();
		consumerThread.start();
		
	}
 
}

M_azed

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
二、多线程(4)JUC并发包--tools--CountDownLatch/CyclicBarrier/Semaphore/Executors/Exchanger

主要包含了 CountDownLatch , CyclicBarrier , Semaphore , Executors , Exchanger 等一.CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。1.原理:CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己...
复制链接

扫一扫