文章目录
- 1、如何实现多线程交替打印字母和数字,打印效果:A1B2C3D4...
- Automic
- BlockingQueue
- ReentrantLock
- LockSupport
- SynchronizedWaitNotify
- TransferQueueWay
- 2、实现多个线程顺序打印abc
- 3、实现阻塞队列
1、如何实现多线程交替打印字母和数字,打印效果:A1B2C3D4…
Automic
public class AutomicWay {
volatile static char num1 = 'A';
volatile static int num2 = 1;
static AtomicInteger atomicInteger = new AtomicInteger(1);
public static void main(String[] args) {
new Thread(() -> {
for (int i = 0; i < 26; i++) {
while (atomicInteger.get() != 1) {
}
System.out.print(num1++);
atomicInteger.set(2);
}
}).start();
new Thread(() -> {
for (int i = 0; i < 26; i++) {
while (atomicInteger.get() != 2) {
}
System.out.print(num2++);
atomicInteger.set(1);
}
}).start();
}
}
BlockingQueue
public class BlockingQueueWay {
volatile static char num1 = 'A';
volatile static int num2 = 1;
public static void main(String[] args) {
BlockingQueue queue1 = new ArrayBlockingQueue(1);
BlockingQueue queue2 = new ArrayBlockingQueue(1);
new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
System.out.print(num1++);
queue2.put("到你");
queue1.take();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
queue2.take();
System.out.print(num2++);
queue1.put("到你");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
ReentrantLock
public class ConditionWay {
volatile static char num1 = 'A';
volatile static int num2 = 1;
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 26; i++) {
System.out.print(num1++);
conditionB.signal();
conditionA.await();
}
conditionB.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 26; i++) {
System.out.print(num2++);
conditionA.signal();
conditionB.await();
}
conditionA.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
}
}
LockSupport
public class LockSupportWay {
static Thread t1,t2 =null;
volatile static char num1 = 'A';
volatile static int num2 = 1;
public static void main(String[] args) {
t1 = new Thread(()->{
for (int i = 0; i < 26; i++) {
System.out.print(num1++);
LockSupport.unpark(t2);
LockSupport.park(t1);
}
});
t2 = new Thread(()->{
for (int i = 0; i < 26; i++) {
LockSupport.park(t2);
System.out.print(num2++);
LockSupport.unpark(t1);
}
});
t1.start();
t2.start();
}
}
SynchronizedWaitNotify
public class SyncWaitNotifyWay {
volatile static char num1 = 'A';
volatile static int num2 = 1;
public static volatile boolean flag = false;
public static void main(String[] args) {
Object o = new Object();
new Thread(()->{
synchronized (o){
flag = true;
for (int i = 0; i < 26; i++) {
System.out.print(num1++);
try {
o.notify();
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify();
}
}).start();
new Thread(()->{
synchronized (o){
// 只是为了保证执行A的先跑
// while (!flag){
// try {
// o.wait();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
for (int i = 0; i < 26; i++) {
System.out.print(num2++);
try {
o.notify();
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify();
}
}).start();
}
}
TransferQueueWay
public class TransferQueueWay {
volatile static char num1 = 'A';
volatile static int num2 = 1;
public static void main(String[] args) {
TransferQueue transferQueue = new LinkedTransferQueue();
new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
System.out.print(transferQueue.take());
transferQueue.transfer(num2++);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
try {
for (int i = 0; i < 26; i++) {
transferQueue.transfer(num1++);
System.out.print(transferQueue.take());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
2、实现多个线程顺序打印abc
核心代码
public class PrintABC {
ReentrantLock lock = new ReentrantLock();
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition();
private int count;
public PrintABC(int count) {
this.count = count;
}
volatile int value = 0;
public void printABC() {
new Thread(new ThreadA()).start();
new Thread(new ThreadB()).start();
new Thread(new ThreadC()).start();
}
class ThreadA implements Runnable {
@Override
public void run() {
lock.lock();
try {
for (int i = 0; i < count; i++) {
while (value % 3 != 0) {
conditionA.await();
}
System.out.print("A");
conditionB.signal();
value++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class ThreadB implements Runnable {
@Override
public void run() {
lock.lock();
try {
for (int i = 0; i < count; i++) {
while (value % 3 != 1) {
conditionB.await();
}
System.out.print("B");
conditionC.signal();
value++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class ThreadC implements Runnable {
@Override
public void run() {
lock.lock();
try {
for (int i = 0; i < count; i++) {
while (value % 3 != 2) {
conditionC.await();
}
System.out.print("C");
conditionA.signal();
value++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
测试代码
public static void main(String[] args) {
PrintABC printABC = new PrintABC(10);
printABC.printABC();
}
// 输出结果:ABCABCABCABCABCABCABCABCABCA
3、实现阻塞队列
核心代码
public class ProviderConsumer<T> {
private int length;
private Queue<T> queue;
private ReentrantLock lock = new ReentrantLock();
private Condition provideCondition = lock.newCondition();
private Condition consumeCondition = lock.newCondition();
public ProviderConsumer(int length) {
this.length = length;
this.queue = new LinkedList<>();
}
public void provide(T product) {
lock.lock();
try {
while (queue.size() >= length) { // 不能换成if,唤醒后,可能条件已经不满足了
provideCondition.await();
}
queue.add(product);
consumeCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public T consume() {
lock.lock();
try {
while (queue.isEmpty()) { // 不能换成if,唤醒后,可能条件已经不满足了
consumeCondition.await();
}
T product = queue.remove();
provideCondition.signal();
return product;
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
return null;
}
}
测试代码
public static void main(String[] args) {
ProviderConsumer<Integer> providerConsumer = new ProviderConsumer<>(5);
new Thread(() -> {
for (int i = 0; i < 10; i++) {
providerConsumer.provide(1);
}
}).start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
providerConsumer.provide(2);
}
}).start();
new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(providerConsumer.consume());
}
}).start();
}