启用3个线程循环打印abcabcabc

为什么80%的码农都做不了架构师？>>>   

多线程面试时，经常会考到一个用3个线程循环打印abcabcabc的问题 现用两种方法做了一下，也看了网上的其他 人的思路，大差不差

一个对象，一个状态位控制，代码如下：

package com.myTread.abcabc.my;

import java.util.concurrent.atomic.AtomicInteger;

public class Print implements Runnable {

    //一个对象锁
    private Object lock;
    //一个线程标志
    private int flag;
    //线程状态
    private AtomicInteger number;
    //下一个线程的状态
    private int next;

    public Print(Object lock, int flag, AtomicInteger number, int next) {
        this.lock = lock;
        this.flag = flag;
        this.number = number;
        this.next = next;
    }

    @Override
    public void run() {
        synchronized(lock){
            for (int i = 0;i<10;i++){
                while(number.intValue() != flag ){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName());
                number.set(next);
                lock.notifyAll();
            }
        }
    }
}

package com.myTread.abcabc.my;

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        AtomicInteger number = new AtomicInteger(1);

        Print a = new Print(lock,1,number,2);
        Thread thread1 = new Thread(a,"a");
        thread1.start();

        Print b = new Print(lock,2,number,3);
        Thread thread2 = new Thread(b,"b");
        thread2.start();

        Print c = new Print(lock,3,number,1);
        Thread thread3 = new Thread(c,"c");
        thread3.start();
    }
}

第二种：用Condition控制

package com.myTread.abcabc.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Print {
    private Lock lock;
    private Condition conditionA;
    private Condition conditionB;
    private Condition conditionC;
    private int number;
    public Print(Lock lock,int  number) {
        this.lock = lock;
        this.conditionA = lock.newCondition();
        this.conditionB = lock.newCondition();
        this.conditionC = lock.newCondition();
        this.number = number;
    }

    public void printA() throws InterruptedException {
        lock.lock();
        try {
            if (number!= 1) {
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName());
            number = 2;
            conditionB.signal();

        } finally {
            lock.unlock();
        }
    }


    public void printB() throws InterruptedException {
        lock.lock();
        try {
            if (number!= 2) {
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName());
            number=3;
            conditionC.signal();

        } finally {
            lock.unlock();
        }
    }

    public void printc() throws InterruptedException {
        lock.lock();
        try {
            if (number!= 3) {
                conditionC.await();
            }
            System.out.println(Thread.currentThread().getName()+" ");
            number=1;
            conditionA.signal();

        } finally {
            lock.unlock();
        }
    }

}

package com.myTread.abcabc.condition;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class TestCondition {

    public static void main(String[] args) throws InterruptedException {
        AtomicInteger num = new AtomicInteger(1);

        final Print print = new Print(new ReentrantLock(), 1);
        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 1; i <= 20; i++) {
                        print.printA();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "a");

        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 1; i <= 20; i++) {
                        print.printB();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "b");

        Thread c = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 20; i++) {
                    try {
                        print.printc();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "c");

        a.start();
        b.start();
        c.start();
    }
}

三 和第一个差不多

package queue;

import java.util.concurrent.atomic.AtomicInteger;

class PrintRes {
    /*    public AtomicInteger flag = new AtomicInteger(1);*/
    public volatile int flag = 1;
}

class Athread extends Thread {
    private PrintRes printRes;

    public Athread(PrintRes printRes) {
        this.printRes = printRes;
    }

    @Override
    public void run() {

        synchronized (printRes) {
            for (int i = 1; i <= 10; i++) {
                while (printRes.flag != 1) {
                    try {
                        printRes.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print("a");
                printRes.flag = 2;
                printRes.notifyAll();
            }
        }
    }
}

class Bthread extends Thread {
    private PrintRes printRes;

    public Bthread(PrintRes printRes) {
        this.printRes = printRes;
    }

    @Override
    public void run() {
        synchronized (printRes) {
            for (int i = 1; i <= 10; i++) {
                while (printRes.flag != 2) {
                    try {
                        printRes.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print("b");
                printRes.flag = 3;
                printRes.notifyAll();
            }
        }
    }
}

class Cthread extends Thread {
    private PrintRes printRes;

    public Cthread(PrintRes printRes) {
        this.printRes = printRes;
    }

    @Override
    public void run() {
        synchronized (printRes) {
            for (int i = 1; i <= 10; i++) {
                while (printRes.flag != 3) {
                    try {
                        printRes.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print("c");
                printRes.flag = 1;
                printRes.notifyAll();
            }
        }
    }
}

public class TestAbc {
    public static void main(String[] args) throws InterruptedException {
        PrintRes printRes = new PrintRes();
        Athread a = new Athread(printRes);
        Bthread b = new Bthread(printRes);
        Cthread c = new Cthread(printRes);
        a.start();
        Thread.sleep(100);
        b.start();
        Thread.sleep(100);
        c.start();
    }
}

 

转载于:https://my.oschina.net/lvzi98/blog/1839362