三个线程轮流执行顺序打印ABC,依次是ABCABCABC......(三种方式)

1.使用synchronized悲观锁

(秋招阿里的一个笔试题,应该写的比较复杂,然后就没有然后了o(╥﹏╥)o)

public class ThreadThreadp {
    private int flag = 0;
    public synchronized void printa() throws InterruptedException {
       while (true)
       {
           if(flag ==0)
           {
               System.out.print("A");
               flag = 1;
               notifyAll();
           }
           wait();
       }
    }
    public synchronized   void printb() throws InterruptedException {
        while (true)
        {
            if(flag ==1)
            {
                System.out.print("B");
                flag = 2;
                notifyAll();
            }
            wait();
        }
    }
    public synchronized void printc() throws InterruptedException {
        while (true) {
            if (flag == 2) {
                System.out.print("C");
                Thread.sleep(1000);
                flag = 0;
                notifyAll();
            }
            wait();
        }
    }
    public static void main(String[]args) throws InterruptedException
    {
        ThreadThreadp t = new ThreadThreadp();
        PrintA printA = new PrintA(t);
        PrintB printB = new PrintB(t);
        PrintC printC = new PrintC(t);
        Thread t1 = new Thread(printA);
        Thread t2 = new Thread(printB);
        Thread t3 = new Thread(printC);
        t1.start();
        t2.start();
        t3.start();
        //Thread t11 = new Thread(printA);
        //Thread t21 = new Thread(printB);
        //Thread t31 = new Thread(printC);
        //t11.start();
        //t21.start();
        //t31.start();

    }

}

class PrintA implements Runnable{
    private  ThreadThreadp t;
    PrintA(ThreadThreadp t){
        this.t=t;
    }
    @Override
    public void run() {
        try {
            t.printa();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class PrintB implements Runnable{

    private  ThreadThreadp t;
    PrintB(ThreadThreadp t){
        this.t=t;
    }
    @Override
    public void run() {
        try {
            t.printb();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class PrintC implements Runnable{
    private  ThreadThreadp t;
    PrintC(ThreadThreadp t){
        this.t=t;
    }
    @Override
    public void run() {
        try {
            t.printc();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
2.使用Lock+Condition
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class threadsan {
    public static void main(String [] args)
    {
        PrintABC printABC = new PrintABC();
        new Thread(new Runnable() {
            @Override
            public void run() {
                printABC.printA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                printABC.printB();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                printABC.printC();
            }
        }).start();
    }
}

class PrintABC{
    private final Lock lock = new ReentrantLock();
    private Condition lockA = lock.newCondition();
    private Condition lockB = lock.newCondition();
    private Condition lockC = lock.newCondition();
    int flag = 0;

    public void printA()
    {
        lock.lock();
        try {
            while (true)
            {
                while (flag!=0)
                    lockA.await();
                System.out.print("A");
                flag =1;
                lockB.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB()
    {
        lock.lock();
        try {
            while (true)
            {
                while (flag!=1)
                    lockB.await();
                System.out.print("B");
                flag =2;
                lockC.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC()
    {
        lock.lock();
        try {
            while (true)
            {
                while (flag!=2)
                    lockC.await();
                System.out.print("C");
                Thread.sleep(1000);
                flag =0;
                lockA.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
3.使用Semaphore实现
//semaphore没用过。。。参考

import java.util.concurrent.Semaphore;

/**
 * Created by huali on 2018/7/25.
 */
public class PrintABCRotationUsingSemaphore {
    public static void main(String[] args) {
        PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore();
        new Thread(() -> printABC.printA()).start();
        new Thread(() -> printABC.printB()).start();
        new Thread(() -> printABC.printC()).start();
    }
}

class PrintABCUsingSemaphore {
    private Semaphore semaphoreA = new Semaphore(1);
    private Semaphore semaphoreB = new Semaphore(0);
    private Semaphore semaphoreC = new Semaphore(0);
    //private int attempts = 0;


    public void printA() {
        print("A", semaphoreA, semaphoreB);
    }

    public void printB() {
        print("B", semaphoreB, semaphoreC);
    }

    public void printC() {
        print("C", semaphoreC, semaphoreA);
    }

    private void print(String name, Semaphore currentSemaphore, Semaphore nextSemaphore) {
        for (int i = 0; i < 10; ) {
            try {
                currentSemaphore.acquire();
                //System.out.println(Thread.currentThread().getName()+" try to print "+name+", attempts : "+(++attempts));
                System.out.println(Thread.currentThread().getName() +" print "+ name);
                i++;
                nextSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

另外参考链接 三个线程轮流执行顺序打印ABC(一):使用Semaphore实现
使用信号量Semaphore循环打印ABC
三个线程轮流执行顺序打印ABC(二):使用Lock+Condition实现
三个线程轮流执行顺序打印ABC(三):使用Lock实现

  • 3
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 10
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值