一、两个线程交叉打印100以内奇偶数,打印结束后线程正常结束。
实现方式一:直接使用Lock就可以。初始化线程时在线程中设置一个标识,0代表打印偶数,1代表打印奇数。
定义一个全局变量num代表要打印的数字,在线程中判断当前要打印的数字是不是和本线程一直,即奇数=奇数线程,偶数对应偶数线程,如果一直则打印,num++,同时唤醒另外的线程;否则进行等待。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test14 {
public static void main(String[] args) throws Exception {
Test14 t = new Test14();
t.run();
}
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();//获取condition对象
int num = 1;
void run() throws Exception {
new Thread(new PrintThread(0)).start();
new Thread(new PrintThread(1)).start();
}
class PrintThread implements Runnable {
int id;
public PrintThread(int id) {
this.id = id;
}
public void run() {
while (num <= 100) {
lock.lock();//获取锁,上锁
try {
if (num % 2 == id) {
System.out.println("id " + id + " - " + num);
num ++;
condition.signalAll();//唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。
} else {
condition.await();//造成当前线程在接到信号或被中断之前一直处于等待状态。
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();//解锁
}
}
}
}
}
实现方式二:
二、3个线程交替打印ABC
1.通过ReentrantLock我们可以很方便的进行显式的锁操作,即获取锁和释放锁,对于同一个对象锁而言,统一时刻只可能有一个线程拿到了这个锁,此时其他线程通过lock.lock()来获取对象锁时都会被阻塞,直到这个线程通过lock.unlock()操作释放这个锁后,其他线程才能拿到这个锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ABC_Lock {
private static Lock lock = new ReentrantLock();// 通过JDK5中的Lock锁来保证线程的访问的互斥
private static int state = 0;//通过state的值来确定是否打印
static class ThreadA extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 0) {// 多线程并发,不能用if,必须用循环测试等待条件,避免虚假唤醒
System.out.print("A");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必须放在finally块中
}
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 1) {// 多线程并发,不能用if,必须用循环测试等待条件,避免虚假唤醒
System.out.print("B");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必须放在finally块中
}
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 2) {// 多线程并发,不能用if,必须用循环测试等待条件,避免虚假唤醒
System.out.print("C");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必须放在finally块中
}
}
}
}
public static void main(String[] args) {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
2.ReentrantLock搭配的通行方式是Condition,如下:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ABC_Condition {
private static Lock lock = new ReentrantLock();
private static Condition A = lock.newCondition();
private static Condition B = lock.newCondition();
private static Condition C = lock.newCondition();
private static int count = 0;
static class ThreadA extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 0)//注意这里是不等于0,也就是说在count % 3为0之前,当前线程一直阻塞状态
A.await(); // A释放lock锁
System.out.print("A");
count++;
B.signal(); // A执行完唤醒B线程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 1)
B.await();// B释放lock锁,当前面A线程执行后会通过B.signal()唤醒该线程
System.out.print("B");
count++;
C.signal();// B执行完唤醒C线程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 2)
C.await();// C释放lock锁
System.out.print("C");
count++;
A.signal();// C执行完唤醒A线程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
参考:https://blog.csdn.net/qq_40664693/article/details/104916479
https://blog.csdn.net/xiaokang123456kao/article/details/77331878