使用wait()和notify()实现Java多线程通信：两个线程交替打印A和B，如ABABAB
public class Test {
public static void main(String[] args) {
final PrintAB print = new PrintAB();
new Thread(new Runnable() {
public void run(){
for(int i=0;i<5;i++) {
print.printA();
}
}
}).start();
new Thread(new Runnable() {
public void run() {
for(int i=0;i<5;i++) {
print.printB(); }
}
}).start();
}
}
class PrintAB{
private boolean flag = true;
public synchronized void printA () {
while(!flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
} }
System.out.print("A");
flag = false;
this.notify();
}
public synchronized void printB () {
while(flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print("B");
flag = true;
this.notify(); }
}
补充知识：Java多个线程顺序打印数字
要求
启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3
方法一: 使用synchronized
三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环
public class TestSequential1 {
private volatile int pos = 1;
private volatile int count = 0;
public void one(int i) {
synchronized (this) {
if (pos == i) {
System.out.println("T-" + i + " " + count);
pos = i % 3 + 1;
count = 0;
} else {
count++;
}
}
}
public static void main(String[] args) {
TestSequential1 demo = new TestSequential1();
for (int i = 1; i <=3; i++) {
int j = i;
new Thread(()->{
while(true) {
demo.one(j);
}
}).start();
}
}
}
输出
T-1 0 T-2 5793 T-3 5285 T-1 2616 T-2 33 T-3 28 T-1 22 T-2 44 T-3 6 T-1 881 T-2 118358 T-3 247380 T-1 30803 T-2 29627 T-3 52044 ...
方法二: 使用synchronized配合wait()和notifyAll()
竞争同步锁时使用wait()和notifyAll(), 可以避免浪费循环
public class TestSequential4 {
private volatile int pos = 1;
private volatile int count = 0;
private final Object obj = new Object();
public void one(int i) {
System.out.println(i + " try");
synchronized (obj) {
System.out.println(i + " in");
try {
while (pos != i) {
count++;
System.out.println(i + " wait");
obj.wait();
}
System.out.println("T-" + i + " " + count);
pos = i % 3 + 1;
count = 0;
obj.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
TestSequential4 demo = new TestSequential4();
for (int i = 3; i >=1; i--) {
int j = i;
new Thread(()->{
while(true) {
demo.one(j);
}
}).start();
}
}
}
输出
3 try 3 in 3 wait 2 try 2 in 2 wait 1 try 1 in T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 1 try 1 in 1 wait T-2 1 2 try 2 in 2 wait T-3 1 3 try 3 in 3 wait 2 wait T-1 2 ...
方法三: 使用可重入锁
用Lock做, 非公平锁, 三个线程竞争, 如果遇上的是自己的数字, 就打印. 这种方式也会浪费大量的循环
public class TestSequential2 {
private final Lock lock = new ReentrantLock();
private volatile int pos = 1;
private volatile int count = 0;
public void one(int i) {
lock.lock();
if (pos == i) {
System.out.println("T-" + i + " " + count);
pos = i % 3 + 1;
count = 0;
} else {
count++;
}
lock.unlock();
}
public static void main(String[] args) {
TestSequential2 demo = new TestSequential2();
for (int i = 1; i <=3; i++) {
int j = i;
new Thread(()->{
while(true) {
demo.one(j);
}
}).start();
}
}
}
输出
T-1 0 T-2 0 T-3 323 T-1 54 T-2 68964 T-3 97642 T-1 6504 T-2 100603 T-3 6989 T-1 1313 T-2 0 T-3 183741 T-1 233 T-2 5081 T-3 164367 ..
方法四: 使用可重入锁, 启用公平锁
和3一样, 但是使用公平锁, 这种情况下基本上可以做到顺序执行, 偶尔会产生多一次循环
private final Lock lock = new ReentrantLock(true);
输出
T-1 0 T-2 0 T-3 0 T-1 0 T-2 0 T-3 0 T-1 0 T-2 0 T-3 0 T-1 0 T-2 0 T-3 1 T-1 1 T-2 1 T-3 1 ...
方法五: 使用Condition
每个线程如果看到不是自己的计数, 就await(), 如果是自己的计数, 就完成打印动作, 再signalAll()所有其他线程去继续运行, 自己在下一个循环后, 即使又继续执行, 也会因为计数已经变了而await.
如果ReentrantLock构造参数使用true, 可以基本消除 ~await 这一步的输出.
public class ReentrantLockCondition2 {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
private volatile int state = 1;
private void handle(int state) {
lock.lock();
try {
while(true) {
while(this.state != state) {
System.out.println(state + " ~await");
condition.await();
}
System.out.println(state);
this.state = state % 3 + 1;
condition.signalAll();
System.out.println(state + " await");
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockCondition2 rlc = new ReentrantLockCondition2();
new Thread(()->rlc.handle(1)).start();
new Thread(()->rlc.handle(2)).start();
new Thread(()->rlc.handle(3)).start();
}
}
方法六: 使用多个Condition
给每个线程不同的condition. 这个和4的区别是, 可以用condition.signal()精确地通知对应的线程继续执行(在对应的condition上await的线程, 可能是多个). 这种情况下是可以多个线程都不unlock锁的情况下进行协作的. 注意下面的while(true)循环是在lock.lock()方法内部的.
public class ReentrantLockCondition {
private static Lock lock = new ReentrantLock();
private static Condition[] conditions = {lock.newCondition(), lock.newCondition(), lock.newCondition()};
private volatile int state = 1;
private void handle(int state) {
lock.lock();
try {
while(true) {
while(this.state != state) {
conditions[state - 1].await();
}
System.out.println(state);
this.state = state % 3 + 1;
conditions[this.state - 1].signal();
conditions[state - 1].await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockCondition rlc = new ReentrantLockCondition();
new Thread(()->rlc.handle(1)).start();
new Thread(()->rlc.handle(2)).start();
new Thread(()->rlc.handle(3)).start();
}
}
以上这篇Java多线程通信:交替打印ABAB实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持亿速云。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
