synchronized
public class Main{
private static volatile int state;
public static void main(String[] args) {
Object o=new Object();
//打印A
new Thread(()->{
//final int num=state;
for(int i=0;
i<10;
i++){
while(state!=0){
synchronized(o){
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}}
}
state=(state+1)%3;
System.out.print("A"+i+"");
synchronized (o){
o.notifyAll();
}
}
}).start();
//打印B
new Thread(()->{
//final int num=state;
for(int i=0;
i<10;
i++){
while(state!=1){
synchronized(o){
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}}
}
state=(state+1)%3;
System.out.print("B"+i+"");
synchronized (o){
o.notifyAll();
}
}
}).start();
//打印C
new Thread(()->{
//final int num=state;
for(int i=0;
i<10;
i++){
while(state!=2){
synchronized(o){
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}}
}
state=(state+1)%3;
System.out.println("C"+i);
synchronized (o){
o.notifyAll();
}
}
}).start();
}}Lock
public class Main{
private static volatile int flag;
public static void main(String[] args) throws InterruptedException {
Lock lock=new ReentrantLock();
new Thread(()->{
for(int i=0;
i<10;
){
lock.lock();
try {
if(flag%3==0){
System.out.println("A"+i);
flag++;
i++;
}
} finally {
lock.unlock();
}
}
}).start();
new Thread(()->{
for(int i=0;
i<10;
){
lock.lock();
try {
if(flag%3==1){
System.out.println("B"+i);
flag++;
i++;
}
} finally {
lock.unlock();
}
}
}).start();
new Thread(()->{
for(int i=0;
i<10;
){
lock.lock();
try {
if(flag%3==2){
System.out.println("C"+i);
flag++;
i++;
}
} finally {
lock.unlock();
}
}
}).start();
}
}
Lock+Condition
public class Main{
private static volatile int flag;
public static void main(String[] args) throws InterruptedException {Lock lock=new ReentrantLock();
Condition conditionA=lock.newCondition();
Condition conditionB=lock.newCondition();
Condition conditionC=lock.newCondition();
new Thread(()->{
lock.lock();
try {
for (int i = 0;
i < 10;
i++) {
while(flag%3!=0){
conditionA.await();
}
flag++;
System.out.println("A" + i);
conditionB.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}).start();
new Thread(()->{
lock.lock();
try {
for (int i = 0;
i < 10;
i++) {
while(flag%3!=1){
conditionB.await();
}
flag++;
System.out.println("B" + i);
conditionC.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}).start();
new Thread(()->{
lock.lock();
try {
for (int i = 0;
i < 10;
i++) {
while(flag%3!=2){
conditionC.await();
}
flag++;
System.out.println("C" + i);
conditionA.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}).start();
}
}Semaphore
```java
public class Main{public static void main(String[] args) throws InterruptedException {
Semaphore semaphoreA=new Semaphore(1);
Semaphore semaphoreB=new Semaphore(0);
Semaphore semaphoreC=new Semaphore(0);
new Thread(()->{
for(int i=0;
i<10;
i++){
try {
semaphoreA.acquire();
System.out.println("A"+i);
semaphoreB.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(()->{
for(int i=0;
i<10;
i++){
try {
semaphoreB.acquire();
System.out.println("B"+i);
semaphoreC.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(()->{
for(int i=0;
i<10;
i++){
try {
semaphoreC.acquire();
System.out.println("C"+i);
semaphoreA.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}推荐阅读
- 代码狂魔|实战证明java中的两把锁ReentrantLock与synchronized的系统调用
- 进程通信方式
- 解决方案|大文件拆分方案的java实践
- 多线程编程（1）（共享内存与锁）
- Java|多线程编程（二）——面试题，每个线程只打印一种字符，多个线程协同顺序打印n次字符串（求大神的其他实现方案）
- 一道面试题（多个线程按顺序输出）
- 多线程|java多线程实现奇偶数输出
- 面试题--三个线程循环打印ABC 10次（另类解决方法）
- 用信号量（互斥锁）实现两个线程交替打印