package cn.zto.countdownlatch;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//使用countdownLathch类实现线程同步
public class CountdownLatchTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CountDownLatch cdOrder = new CountDownLatch(1);
final CountDownLatch cdAnswer = new CountDownLatch(3);
for (int i = 1; i <= 3; i++) {
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println("线程"
+ Thread.currentThread().getName() + "正准备接受命令");
cdOrder.await();
System.out.println("线程"
+ Thread.currentThread().getName() + "已接受命令");
Thread.sleep((long) (Math.random() * 10000));
System.out
.println("线程"
+ Thread.currentThread().getName()
+ "回应命令处理结果");
cdAnswer.countDown();
} catch (Exception e) {
}
}
};
service.execute(runnable);
}
try {
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程" + Thread.currentThread().getName()
+ "即将发布命令");
cdOrder.countDown();
System.out.println("线程" + Thread.currentThread().getName()
+ "已发送命令，正在等待结果");
cdAnswer.await();
System.out.println("线程" + Thread.currentThread().getName()
+ "已收到所有响应结果");
} catch (Exception e) {
e.printStackTrace();
}
service.shutdown();
}
}
运行结果：
线程pool-1-thread-2正准备接受命令
线程pool-1-thread-3正准备接受命令
线程pool-1-thread-1正准备接受命令
线程main即将发布命令
线程main已发送命令，正在等待结果
线程pool-1-thread-2已接受命令
线程pool-1-thread-3已接受命令
线程pool-1-thread-1已接受命令
线程pool-1-thread-3回应命令处理结果
线程pool-1-thread-2回应命令处理结果
线程pool-1-thread-1回应命令处理结果
线程main已收到所有响应结果
package cn.zto.cyclicbarrier;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//使用CyclicBarrier实现线程同步
public class CyclicBarrierTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CyclicBarrier cb = new CyclicBarrier(3);
for (int i = 1; i <= 3; i++) {
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Thread.sleep((long) (Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) +
"个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
cb.await();
Thread.sleep((long) (Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) +
"个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
cb.await();
Thread.sleep((long) (Math.random()*10000));
System.out.println("线程" + Thread.currentThread().getName() +
"即将到达集合地点3，当前已有" + (cb.getNumberWaiting()+1) +
"个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，回家吧":"正在等候"));
cb.await();
} catch (Exception e) {
e.printStackTrace();
}
}
};
service.execute(runnable);
}
service.shutdown();
}
}
运行结果：
线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候
线程pool-1-thread-3即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-3即将到达集合地点2，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点2，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点3，当前已有2个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点3，当前已有3个已经到达，都到齐了，回家吧
package cn.zto.exchanger;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//通过exchanger实现线程同步
public class ExchangerTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final Exchanger exchanger = new Exchanger();
service.execute(new Runnable(){
public void run() {
try {
String data1 = "XXXXX";
System.out.println("线程" + Thread.currentThread().getName() +
"正在把数据" + data1 +"换出去");
Thread.sleep((long)(Math.random()*10000));
String data2 = (String)exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() +
"换回的数据为" + data2);
}catch(Exception e){
}
}
});
service.execute(new Runnable(){
public void run() {
try {
String data1 = "YYYYY";
System.out.println("线程" + Thread.currentThread().getName() +
"正在把数据" + data1 +"换出去");
Thread.sleep((long)(Math.random()*10000));
String data2 = (String)exchanger.exchange(data1);
System.out.println("线程" + Thread.currentThread().getName() +
"换回的数据为" + data2);
}catch(Exception e){
}
}
});
}
}
运行结果：
线程pool-1-thread-1正在把数据XXXXX换出去
线程pool-1-thread-2正在把数据YYYYY换出去
线程pool-1-thread-2换回的数据为XXXXX
线程pool-1-thread-1换回的数据为YYYYY
package cn.zto.semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
//信号灯
public class SemaphoreTest {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final Semaphore sp = new Semaphore(3);
for (int i = 1; i < 10; i++) {
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
sp.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() +
"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
try {
Thread.sleep((long)(Math.random()*10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() +
"即将离开");
sp.release();
//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
System.out.println("线程" + Thread.currentThread().getName() +
"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");
}
};
service.execute(runnable);
}
}
}
运行结果：
线程pool-1-thread-1进入，当前已有2个并发
线程pool-1-thread-2进入，当前已有2个并发
线程pool-1-thread-4进入，当前已有3个并发
线程pool-1-thread-2即将离开
线程pool-1-thread-5进入，当前已有3个并发
线程pool-1-thread-2已离开，当前已有3个并发
线程pool-1-thread-1即将离开
线程pool-1-thread-1已离开，当前已有2个并发
线程pool-1-thread-6进入，当前已有3个并发
线程pool-1-thread-4即将离开
线程pool-1-thread-4已离开，当前已有2个并发
线程pool-1-thread-9进入，当前已有3个并发
线程pool-1-thread-5即将离开
线程pool-1-thread-8进入，当前已有3个并发
线程pool-1-thread-5已离开，当前已有3个并发
线程pool-1-thread-6即将离开
线程pool-1-thread-6已离开，当前已有2个并发
线程pool-1-thread-3进入，当前已有3个并发
线程pool-1-thread-9即将离开
线程pool-1-thread-7进入，当前已有3个并发
线程pool-1-thread-9已离开，当前已有3个并发
线程pool-1-thread-3即将离开
线程pool-1-thread-3已离开，当前已有2个并发
线程pool-1-thread-8即将离开
线程pool-1-thread-8已离开，当前已有1个并发
线程pool-1-thread-7即将离开
线程pool-1-thread-7已离开，当前已有0个并发
相关推荐
Java多线程同步是指在Java语言中，如何使用synchronized关键字和其他同步机制来确保多线程程序的正确执行。在Java语言中，synchronized关键字用于对方法或者代码块进行同步，但是仅仅使用synchronized关键字还不能...
java多线程同步互斥访问实例，对于初学者或是温故而知新的同道中人都是一个很好的学习资料
在Java编程环境中，...总之，使用Java线程实现数据库主从同步更新是一种常见且实用的技术手段，它涉及到多线程编程、数据库操作、事务管理等多个方面。理解和掌握这些知识点对于开发高可用性的分布式系统至关重要。
线程同步是 Java 编程中的一种机制，用于控制多个线程之间的资源访问顺序，以避免线程之间的冲突和数据不一致。线程同步的目的就是避免线程“同步”执行，即让多个线程之间排队操作共享资源。 关于线程同步，需要...
### Java中的线程同步方法详解 #### 引言 在多线程编程中，线程同步是一项关键的技术，用于确保当多个线程访问共享资源时，不会发生数据混乱或竞态条件。Java提供了多种机制来实现线程同步，包括synchronized...
在Java编程中，线程同步和互斥是多线程编程中的重要概念，它们用于解决多个线程同时访问共享资源时可能出现的问题。本项目通过一个生产者消费者问题的实例，展示了如何在Java中实现线程间的同步与互斥。 生产者消费...
Java多线程同步是编程中一个非常重要的概念，特别是在并发编程和高并发系统设计中起到关键作用。在Java中，为了保证线程安全，避免数据竞争和不一致的状态，我们通常会使用同步机制来控制对共享资源的访问。本文将...
java线程同步java线程同步java线程同步
Java线程(二)：线程同步synchronized和volatile 详细讲解Java 同步的原理技术资料
总结一下，Java线程同步的关键点： 1. **线程同步是为了解决共享资源的并发访问问题，防止数据不一致和冲突。** 2. **同步意味着线程排队，依次访问共享资源，而不是同时访问。** 3. **只有共享变量（可变状态）才...
Java多线程同步是编程中一个非常重要的概念，特别是在并发编程中，用于解决多个线程访问共享资源时可能引发的数据不一致问题。本实例通过一个简单的火车票售票系统来演示同步机制的应用。 在这个实例中，我们创建了...
本文将深入探讨Java多线程中的关键知识点，包括创建线程、主线程、线程优先级、线程组、线程同步以及线程间的通信。 1. **创建线程** 在Java中，可以通过两种方式创建线程：继承`Thread`类或实现`Runnable`接口。...
Java多线程同步是Java编程中关键的并发概念，它涉及到如何在多个线程访问共享资源时保持数据的一致性和完整性。`java.util.concurrent`包是Java提供的一个强大的并发工具库，它为开发者提供了多种线程安全的工具，...
在Java编程语言中，线程同步是一个关键概念，特别是在多线程编程中，它用于确保多个线程在访问共享资源时能正确协调，避免数据不一致性和竞态条件。五子棋游戏是一个典型的多线程应用场景，因为它涉及到两个玩家交替...
在Java编程语言中，多线程同步是一种控制多个线程并发执行的重要机制，它确保了共享资源的安全访问，防止数据不一致性和竞态条件的发生。本文将深入探讨Java中的多线程同步方法，并通过实例来阐述其工作原理。 首先...
根据给定文件的信息，本篇文档是关于Java多线程同步技术在简易模拟售票系统中的应用研究。文档详细介绍了多线程的概念、如何在Java中创建线程、线程同步技术以及如何利用这些技术来解决共享资源访问时的数据一致性...
Java中的`synchronized`关键字是用于实现线程同步的关键机制，主要目的是解决多线程环境下的数据安全问题。当多个线程访问共享资源时，如果没有适当的同步控制，可能会导致数据不一致或者竞态条件等问题。线程同步...
在“操作系统实验 多线程同步与互斥 java编写 有界面”的实验中，可能需要设计一个图形用户界面（GUI），通过按钮或事件触发线程的创建和同步操作，直观地展示线程间的交互和同步效果。例如，可以模拟银行账户转账，...
Java线程同步与通信是多线程编程中的关键概念，用于解决并发访问共享资源时可能出现的数据不一致性和竞态条件问题。以下将详细介绍这两个主题，以及如何通过代码示例进行演示。 1. **线程同步**： 线程同步是确保...