三个线程ABC，交替打印ABC

来源：互联网发布：linux 进程stdio 编辑：程序博客网时间：2024/06/01 14:40

synchronized

问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC→ThreadA……循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。

主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就是前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印字母，之后首先调用self.notifyAll()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B,A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A……

为了避免JVM启动ThreadA、ThreadB、ThreadC三个线程顺序的不确定性。需要让A,B,C三个线程以确定的顺序启动，中间加一段sleep确保前一个线程已启动。

public class ABC {    public static class ThreadPrinter implements Runnable {        private String name;        private Object prev;        private Object self;         private ThreadPrinter(String name, Object prev, Object self) {            this.name = name;            this.prev = prev;            this.self = self;        }         @Override        public void run() {            int count = 10;            while (count > 0) {//多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒                synchronized (prev) {    // 先获取 prev 锁                    synchronized (self) {// 再获取 self 锁                        System.out.print(name);                        count--;                         self.notifyAll();// 先释放 self，唤醒其他线程竞争self锁                    }                    try {                        prev.wait();     // 再释放 prev，休眠等待唤醒                        /**                         * 注意的是notify()调用后，并不是马上就释放对象锁，而是在相应的synchronized(){}语句块执行结束，自动释放锁，                         * JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。                         */                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }    }     public static void main(String[] args) throws Exception {        Object a = new Object();        Object b = new Object();        Object c = new Object();        ThreadPrinter pa = new ThreadPrinter("A", c, a);        ThreadPrinter pb = new ThreadPrinter("B", a, b);        ThreadPrinter pc = new ThreadPrinter("C", b, c);          new Thread(pa).start();        Thread.sleep(10);        new Thread(pb).start();        Thread.sleep(10);        new Thread(pc).start();        Thread.sleep(10);    }}

Lock

public class ABC_Lock {    private static Lock lock = new ReentrantLock();//通过JDK5中的Lock锁来保证线程的访问的互斥    private static int state = 0;     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();// lock()和unlock()操作结合try/catch使用                }            }        }    }     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();// lock()和unlock()操作结合try/catch使用                }            }        }    }     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();// lock()和unlock()操作结合try/catch使用                }            }        }    }     public static void main(String[] args) {        new ThreadA().start();        new ThreadB().start();        new ThreadC().start();    }}

Condition

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)                        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锁                    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.println("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();        ThreadC threadC = new ThreadC();        threadC.start();        threadC.join();// main线程调用threadC.join()，会等threadC执行完成后，再执行main线程        System.out.println(count);    }}

Semaphore

public class ABC_Semaphore {    // 以A开始的信号量,初始信号量数量为1    private static Semaphore A = new Semaphore(1);    // B、C信号量,A完成后开始,初始信号数量为0    private static Semaphore B = new Semaphore(0);    private static Semaphore C = new Semaphore(0);     static class ThreadA extends Thread {        @Override        public void run() {            try {                for (int i = 0; i < 10; i++) {                    A.acquire();// A获取信号执行                    System.out.print("A");                    B.release();// B释放信号，B信号量为1，可以执行                }            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }     static class ThreadB extends Thread {        @Override        public void run() {            try {                for (int i = 0; i < 10; i++) {                    B.acquire();                    System.out.print("B");                    C.release();                }            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }     static class ThreadC extends Thread {        @Override        public void run() {            try {                for (int i = 0; i < 10; i++) {                    C.acquire();                    System.out.println("C");                    A.release();                }            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }     public static void main(String[] args) throws InterruptedException {        new ThreadA().start();        new ThreadB().start();        new ThreadC().start();    }}

1 0