一个线程间通信的面试题:三个线程循环打印ABC第一个线程打印A,第二个线程打印B,第三个线程打印C

wati和notify实现
public class Test {
    public static void main(String[] args) {
        LockObject lock= new LockObject();
        Thread t1 = new Thread(new Task(lock,"A"));
        Thread t2 = new Thread(new Task(lock,"B"));
        Thread t3 = new Thread(new Task(lock,"C"));
        t1.start();
        t2.start();
        t3.start();
    }
}

class LockObject{
    volatile int count=1;
}
class Task implements Runnable{
    private LockObject lock;
    private String str;
    public Task(LockObject lock,String str){
        this.lock=lock;
        this.str=str;
    }
    @Override
    public void run() {
        for(int i=1;i<=10;i++){
            synchronized (lock){
                try {
                    boolean flag=true;
                    while(flag){
                        if("A".equals(this.str)&&lock.count%3==1){
                            System.out.print(str);
                            ++lock.count;
                            flag=false;
                            lock.notify();
                            lock.wait();
                        }else if("B".equals(this.str)&&lock.count%3==2){
                            System.out.print(str);
                            ++lock.count;
                            flag=false;
                            lock.notify();
                            lock.wait();
                        }else if("C".equals(this.str)&&lock.count%3==0) {
                            System.out.print(str);
                            ++lock.count;
                            flag=false;
                            lock.notify();
                            lock.wait();
                        }else{
                            lock.notify();
                            lock.wait();
                        }
                        if(lock.count==31){
                            lock.notify();
                            flag=false;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
LockSupprot实现
import java.util.concurrent.locks.LockSupport;

public class Test {
    static Thread t1=null, t2=null,t3=null;
    public static void main(String[] args) {

        t1=new Thread(()->{
            for(int i=1;i<=10;i++){
                System.out.print("A");
                LockSupport.unpark(t2);
                LockSupport.park();
            }

        });
        t2=new Thread(()->{
            for(int i=1;i<=10;i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(t3);
            }
        });
        t3=new Thread(()->{
            for(int i=1;i<=10;i++) {
                LockSupport.park();
                System.out.print("C");
                LockSupport.unpark(t1);
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

}
RettrentLock Condition
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    static Thread t1=null,t2=null,t3=null;
    public static void main(String[] args) {
        CountDownLatch latch=new CountDownLatch(1);//保证线程先执行
        ReentrantLock reentrantLock=new ReentrantLock();
        Condition a = reentrantLock.newCondition();
        Condition b = reentrantLock.newCondition();
        Condition c = reentrantLock.newCondition();
        new Thread(()->{
            try {
                reentrantLock.lock();
                for(int i=0;i<10;i++){
                    System.out.print("A");
                    try {
                        latch.countDown();
                        b.signal();
                        a.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                b.signal();
                reentrantLock.unlock();
            }
        }).start();
        new Thread(()->{
            try {
                latch.await();
                reentrantLock.lock();
                for(int i=0;i<10;i++){
                    System.out.print("B");
                    try {
                        c.signal();
                        b.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                c.signal();
                reentrantLock.unlock();
            }
        }).start();
        new Thread(()->{
            try {
                latch.await();
                reentrantLock.lock();
                for(int i=0;i<10;i++){
                    System.out.print("C");
                    try {
                        a.signal();
                        c.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }).start();
    }
}
  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值