标签：互斥 ring http 引入 mic star count 共享 time
多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们希望CPU按照我们的规律执行线程，此时就需要线程之间协调通信。
线程间通信常用方式如下：
l 休眠唤醒方式：Object的wait、notify、notifyAll 和 Condition的await、signal、signalAll
l CountDownLatch：用于某个线程A等待若干个其他线程执行完之后，它才执行
l CyclicBarrier：一组线程等待至某个状态之后再全部同时执行
l Semaphore：用于控制对某组资源的访问权限
object的wait、notify、notifyAll
package com.mall.thread;
/**
* @Auther: mengyang
* @Date: 2020/1/21 0021 15:05
* @Description:使用Object类的通信
* @statement:
*/
public class WaitNotifyRunnable{
private Object obj = new Object();
private Integer i = 0;
//单数
public void odd(){
while (i<10){
synchronized (obj){
if(i%2 == 1){
System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
i++;
obj.notify();
}else{
try{
obj.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
}
//偶数
public void even(){
while (i<10){
synchronized (obj){
if(i%2 == 0){
System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
i++;
obj.notify();
}else{
try{
obj.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
}
//测试
public static void main(String[] args) {
final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
runnable.odd();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
runnable.even();
}
});
thread1.start();
thread2.start();
}
}
运行效果：
Condition的await、signal、signalAll
package com.mall.thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Auther: mengyang
* @Date: 2020/1/21 0021 15:46
* @Description:使用Condition的await、signal
* @statement:
*/
public class AwaitSignalRunnable {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private Integer i = 0;
//奇数
private void odd(){
while (i<10){
lock.lock();
try{
if(i%2 == 1){
System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
i++;
condition.signal();
}else{
condition.await();
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
//偶数
private void even(){
while (i<10){
lock.lock();
try{
if(i%2 == 0){
System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
i++;
condition.signal();
}else{
condition.await();
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
final AwaitSignalRunnable runnable = new AwaitSignalRunnable();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
runnable.odd();
}
}, "奇数线程");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
runnable.even();
}
}, "偶数线程");
thread1.start();
thread2.start();
}
}
运行结果：
Object和condition休眠唤醒的区别
l object wait()必须在synchronized(同步锁) 下使用
l Object wait()必须要通过notify() 方法唤醒
l condition await() 必须和lock(互斥锁/共享锁) 配合使用
l condition await()必须通过signal()方法唤醒
CountDownLatch是在java1.5被引入的，存在于java.util.concurrent包下。
CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。
每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
示例代码：
package com.mall.thread;
import java.util.concurrent.CountDownLatch;
/**
* @Auther: mengyang
* @Date: 2019/1/21 0021 16:46
* @Description:使用CountDownLatch
* 每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
* @statement:
*/
public class CountDown {
private Integer i = 0;
private CountDownLatch countDownLatch = new CountDownLatch(1);
//奇数
public void odd(){
while(i <10){
if(i%2 == 1){
System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
i++;
countDownLatch.countDown();
} else {
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//偶数
public void even(){
while(i <10){
if(i%2 == 0){
System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
i++;
countDownLatch.countDown();
} else {
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//测试
public static void main(String[] args){
final CountDown countDown = new CountDown();
Thread t1 = new Thread(new Runnable() {
public void run() {
countDown.odd();
}
},"奇数");
Thread t2 = new Thread(new Runnable() {
public void run() {
countDown.even();
}
},"偶数");
t1.start();
t2.start();
}
}
执行效果：
CyclicBarrier是在java1.5被引入的，存在于java.util.concurrent包下。
CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。
CyclicBarrier底层是
三个线程同时启动，示例代码如下：
package com.mall.thread;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* @Auther: mengyang
* @Date: 2020/1/21 0021 09:52
* @Description:使用CyclicBarrier
* CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。
* @statement:
*/
public class CyclicBarrierDemo {
public static void main(String[] args){
final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"：准备...");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
}
},"线程1").start();
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"：准备...");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
}
},"线程2").start();
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"：准备...");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
}
},"线程3").start();
}
}
执行效果如下：三个线程同时启动
Semaphore是在java1.5被引入的，存在于java.util.concurrent包下。
Semaphore用于控制对某组资源的访问权限。
工人使用机器工作，示例代码如下：
package com.mall.thread;
import java.util.concurrent.Semaphore;
/**
* @Auther: mengyang
* @Date: 2019/1/21 0021 16:56
* @Description: 使用Semaphore
* emaphore用于控制对某组资源的访问权限
* @statement:
*/
public class SemaphoreDemo {
static class Machine implements Runnable{
private int num;//工号
private Semaphore semaphore;
public Machine(int num, Semaphore semaphore) {
this.num = num;
this.semaphore = semaphore;
}
public void run() {
try {
semaphore.acquire();//请求机器
System.out.println("工人"+this.num+"请求机器，正在使用机器");
Thread.sleep(1000);
System.out.println("工人"+this.num+"使用完毕，已经释放机器");
semaphore.release();//释放机器
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args){
int worker = 8;//工人数
Semaphore semaphore = new Semaphore(3);//机器数
for (int i=0; i< worker; i++){
new Thread(new Machine(i, semaphore)).start();
}
}
}
执行效果如下：
sleep和wait区别
wait和notify区别
wait和notify都是Object中的方法
wait和notify执行前线程都必须获得对象锁
wait的作用是使当前线程进行等待
notify的作用是通知其他等待当前线程的对象锁的线程
标签：互斥 ring http 引入 mic star count 共享 time
原文地址：https://www.cnblogs.com/mengY/p/12222393.html
