JAVA-并发工具类

3.5 并发工具类-CountDownLatch

CountDownLatch类 :

使用场景： 让某一条线程等待其他线程执行完毕之后再执行

代码实现 :

import java.util.concurrent.CountDownLatch;
public class ChileThread1 extends Thread {
			private CountDownLatch countDownLatch;
			public ChileThread1(CountDownLatch countDownLatch) {
			this.countDownLatch = countDownLatch;
}
@Override
public void run() {
//1.吃饺子
for (int i = 1; i <= 10; i++) {
			System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
			countDownLatch.countDown();
}
}

import java.util.concurrent.CountDownLatch;
public class ChileThread2 extends Thread {
private CountDownLatch countDownLatch;
public ChileThread2(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
//1.吃饺子
  for (int i = 1; i <= 15; i++) {
System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.countDown();
}
}
import java.util.concurrent.CountDownLatch;
public class ChileThread3 extends Thread {
private CountDownLatch countDownLatch;
public ChileThread3(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
//1.吃饺子
for (int i = 1; i <= 20; i++) {
System.out.println(getName() + "在吃第" + i + "个饺子");
}
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.countDown();
}
}

import java.util.concurrent.CountDownLatch;
public class MotherThread extends Thread {
private CountDownLatch countDownLatch;
public MotherThread(CountDownLatch countDownLatch) {
				this.countDownLatch = countDownLatch;
				}
        @Override
        public void run() {
        //1.等待
        try {
        //当计数器变成0的时候，会自动唤醒这里等待的线程。
        countDownLatch.await();
        } catch (InterruptedException e) {
        e.printStackTrace();
          }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
					}
}

import java.util.concurrent.CountDownLatch;
public class MyCountDownLatchDemo {
public static void main(String[] args) {
            //1.创建CountDownLatch的对象，需要传递给四个线程。
            //在底层就定义了一个计数器，此时计数器的值就是3
            CountDownLatch countDownLatch = new CountDownLatch(3);
            //2.创建四个线程对象并开启他们。
            MotherThread motherThread = new MotherThread(countDownLatch);
            motherThread.start();
            ChileThread1 t1 = new ChileThread1(countDownLatch);
            t1.setName("小明");
            ChileThread2 t2 = new ChileThread2(countDownLatch);
            t2.setName("小红");
            ChileThread3 t3 = new ChileThread3(countDownLatch);
            t3.setName("小刚");
            t1.start();
            t2.start();
            t3.start();
						}
}

总结 :

• CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。
• await()：让线程等待，当计数器为0时，会唤醒等待的线程
• countDown()： 线程执行完毕时调用，会将计数器-1。

3.6 并发工具类-Semaphore

使用场景 :

可以控制访问特定资源的线程数量。

实现步骤 :

1. 需要有人管理这个通道
2. 当有车进来了，发通行许可证
3. 当车出去了，收回通行许可证
4. 如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

import java.util.concurrent.Semaphore;
public class MyRunnable implements Runnable {
//1.获得管理员对象，
private Semaphore semaphore = new Semaphore(2);
@Override
public void run() {
//2.获得通行证
try {
semaphore.acquire();
//3.开始行驶
System.out.println("获得了通行证开始行驶");
Thread.sleep(2000);
System.out.println("归还通行证");
//4.归还通行证
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public class MySemaphoreDemo {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
for (int i = 0; i < 100; i++) {
new Thread(mr).start();
}
}
}