Java 线程 - 线程顺序执行

• 1 三个线程顺序打出abc

package practice;

public class T1 {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new MyThread("a"));
        Thread t2 = new Thread(new MyThread("b"));
        Thread t3 = new Thread(new MyThread("c"));

        t1.start();
        t1.join();
        
        
        t2.start();
        t2.join();
        
        t3.start();
        t3.join();
    }

    static class MyThread implements Runnable {

        String str;

        public MyThread(String str) {
            this.str = str;
        }

        @Override
        public void run() {
            System.out.println(str);
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(str + "end");
        }

    }

}

• 2 三个线程顺序打出abc 30次[Semaphore]

package practice;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class T1 {

    static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Semaphore sem_a = new Semaphore(0);
        Semaphore sem_b = new Semaphore(0);
        Semaphore sem_c = new Semaphore(0);

        Thread t1 = new Thread(new MyThread("a", sem_a, sem_b));
        Thread t2 = new Thread(new MyThread("b", sem_b, sem_c));
        Thread t3 = new Thread(new MyThread("c", sem_c, sem_a));

        t1.start();
        t2.start();
        t3.start();

        sem_a.release();

    }

    static class MyThread implements Runnable {

        String str;
        Semaphore self, next;

        public MyThread(String str, Semaphore selft, Semaphore next) {
            this.str = str;
            this.self = selft;
            this.next = next;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    self.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                count.addAndGet(1);
                
                if (count.get() / 10 >= 3) {
                    next.release();
                    break;
                } else {
                    System.out.println(count.get() + ":" + str);
                    next.release();
                }

            }
        }

    }

}

• 3 三个线程顺序打出abc 30次[Synchronized, wait, notifyall]

package practice;

public class T2 {

    static int count = 0;
    static int currentIndex = 0;

    public static void main(String[] args) {

        Object lock = new Object();

        Thread t1 = new Thread(new MyThread(lock, 0, "a"));
        Thread t2 = new Thread(new MyThread(lock, 1, "b"));
        Thread t3 = new Thread(new MyThread(lock, 2, "c"));
        t1.start();
        t2.start();
        t3.start();

    }

    static class MyThread implements Runnable {

        Object lock;
        int index;
        String string;

        public MyThread(Object lock, int index, String str) {
            this.lock = lock;
            this.index = index;
            this.string = str;
        }

        @Override
        public void run() {

            while (true) {
                synchronized (lock) {  //gain the lock
                    while (index != currentIndex && count <= 29) {// if it is not, release the lock.
                        try {
                            lock.wait(); // The current thread must own this object's monitor, that's why it is in synchronized block
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //gained the lock and do the business

                    if (count > 29) {
                        lock.notifyAll();
                        break;
                    }

                    System.out.println(count + ":" + string);
                    count++;
                    currentIndex = (currentIndex + 1) % 3;

                    lock.notifyAll();// let's ask for the lock together. A thread waits on an object's monitor by calling one of the wait methods. 
                }

            }

        }

    }
}

• 3 三个线程顺序打出abc 30次[Lock, Condition]

package practice;

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

//Condition 实现可以提供不同于 Object 监视器方法的行为和语义，比如受保证的通知排序，或者在执行通知时不需要保持一个锁。
public class T3 {

    static ReentrantLock lock = new ReentrantLock();

    static Condition cona = lock.newCondition();
    static Condition conb = lock.newCondition();
    static Condition conc = lock.newCondition();

    static int count = 0;
    static int currentIndex = 0;

    public static void main(String[] args) {
        Thread threada = new Thread(new MyThread(lock, cona, conb, "a", 0));
        Thread threadb = new Thread(new MyThread(lock, conb, conc, "b", 1));
        Thread threadc = new Thread(new MyThread(lock, conc, cona, "c", 2));

        threada.start();
        threadb.start();
        threadc.start();

    }

    static class MyThread implements Runnable {

        Condition self, next;
        String str;
        int index;
        Lock lock;

        public MyThread(Lock lock, Condition self, Condition next, String str, int index) {
            this.lock = lock;
            this.self = self;
            this.next = next;
            this.str = str;
            this.index = index;
        }

        @Override
        public void run() {

            while (true) {
                try {
                    lock.lock();
                    while (index != currentIndex && count < 30) {
                        try {
                            self.await(); //与此 Condition 相关的锁以原子方式释放，并且出于线程调度的目的，将禁用当前线程. 但是可能出现虚假唤醒,所以还是while
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    if (count >= 30) {
                        next.signal();
                        break;
                    }
                    System.out.println(count + ":" + str);
                    count++;
                    currentIndex = (currentIndex + 1) % 3;
                    next.signal();
                } finally {
                    lock.unlock();
                }

            }
        }

    }

}