Java多个线程顺序打印数字

要求

启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3

方法一: 使用synchronized

三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环

public class TestSequential1 {
    private volatile int pos = 1;
    private volatile int count = 0;

    public void one(int i) {
        synchronized (this) {
            if (pos == i) {
                System.out.println("T-" + i + " " + count);
                pos = i % 3 + 1;
                count = 0;
            } else {
                count++;
            }
        }
    }

    public static void main(String[] args) {
        TestSequential1 demo = new TestSequential1();
        for (int i = 1; i <=3; i++) {
            int j = i;
            new Thread(()->{
                while(true) {
                    demo.one(j);
                }
            }).start();
        }
    }
}

输出

T-1 0
T-2 5793
T-3 5285
T-1 2616
T-2 33
T-3 28
T-1 22
T-2 44
T-3 6
T-1 881
T-2 118358
T-3 247380
T-1 30803
T-2 29627
T-3 52044
...

 

方法二: 使用synchronized配合wait()和notifyAll()

竞争同步锁时使用wait()和notifyAll(), 可以避免浪费循环

public class TestSequential01 {
    private volatile int pos = 1;
    private volatile int count = 0;
    private final Object obj = new Object();

    public void run(int i) {
        int next = i % 3 + 1;
        while(true) {
            synchronized (obj) {
                System.out.println(i + " in");
                try {
                    while (pos != i) {
                        count++;
                        System.out.println(i + " wait");
                        obj.wait();
                    }
                    System.out.println("T-" + i + " " + count);
                    pos = next;
                    count = 0;
                    obj.notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        TestSequential01 demo = new TestSequential01();
        for (int i = 3; i >=1; i--) {
            int j = i;
            new Thread(()->{
                demo.run(j);
            }).start();
        }
    }
}

输出

3 in
3 wait
1 in
T-1 1
1 in
1 wait
2 in
T-2 1
2 in
2 wait
1 wait
T-3 2
3 in
3 wait
T-1 1
1 in
1 wait
T-2 1
2 in
2 wait
1 wait
T-3 2
3 in
3 wait
T-1 1
1 in
1 wait

 

方法三: 使用可重入锁

用Lock做, 非公平锁, 三个线程竞争, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环

public class TestSequential01 {
    private final Lock lock = new ReentrantLock();
    private volatile int pos = 1;
    private volatile int count = 0;

    public void run(int i) {
        int next = i % 3 + 1;
        while(true) {
            lock.lock();
            if (pos == i) {
                System.out.println("T-" + i + " " + count);
                pos = next;
                count = 0;
            } else {
                count++;
            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TestSequential01 demo = new TestSequential01();
        for (int i = 1; i <=3; i++) {
            int j = i;
            new Thread(()->{
                demo.run(j);
            }).start();
        }
    }
}

输出

T-1 0
T-2 0
T-3 323
T-1 54
T-2 68964
T-3 97642
T-1 6504
T-2 100603
T-3 6989
T-1 1313
T-2 0
T-3 183741
T-1 233
T-2 5081
T-3 164367
..

 

方法四: 使用可重入锁, 启用公平锁

和3一样, 但是使用公平锁, 这种情况下基本上可以做到顺序执行, 偶尔会产生多一次循环

private final Lock lock = new ReentrantLock(true);

输出

T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 0
T-1 0
T-2 0
T-3 1
T-1 1
T-2 1
T-3 1
...

.

方法五: 使用Condition

给每个线程不同的condition. 可以用condition.signal()精确地通知对应的线程继续执行(在对应的condition上await的线程, 可能是多个).

public class TestSequential01 {
    private static Lock lock = new ReentrantLock();
    private static Condition[] conditions = {lock.newCondition(), lock.newCondition(), lock.newCondition()};
    private volatile int state = 1;

    private void run(final int self) {
        int next = self % 3 + 1;
        while(true) {
            lock.lock();
            try {
                while(this.state != self) {
                    conditions[self - 1].await();
                }
                System.out.println(self);
                this.state = next;
                conditions[next - 1].signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TestSequential01 rlc = new TestSequential01();
        for (int i = 1; i < 4; i++) {
            int j = i;
            new Thread(()->rlc.run(j)).start();
        }
    }
}

　　

总结

在使用wait()和await()的竞争环境, 因为被notifyAll()和signal()之后到线程回到执行之前, 条件可能发生变化, 所以必须在wait()和await()外包使用while循环检测条件, 这是一个通用方法