多线程练习题目--利用多线程打印数字

多线程练习题目

启动3个线程打印数字，要求：线程1先打印1，2，3，然后线程2打印4，5，6，线程3打印7，8，9，接着再由线程1打印10，11，12，依此类推，直到打印到45，使用多线程实现该打印操作

先创建打印类

/**
 * 打印类
 * @author 小明
 *
 */
public class Print {
    // num为即将打印的数字
    private static Integer num = 1;

    public void print() {
        for (int i = 0; i < 3; i++) {
            System.out
                    .println(Thread.currentThread().getName() + " : " + num++);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通过Thread.currentThread()获取当前正在执行的线程对象

测试，创建3个线程，分别打印数字

/**
 * 测试类
 * 
 * @author 小明
 *
 */
public class Test3 {
    // 当前打印状态 1：线程1 2：线程2 3：线程3
    static int state = 1;

    public static void main(String[] args) {
        final Print print = new Print();

        /*
         * 线程1打印
         */
        new Thread(new Runnable() {

            @Override
            public void run() {
                // 3个线程打印45个数字, 单个线程每次打印3个连续数字, 因此每个线程只需执行5次打印任务
                for (int i = 0; i < 5; i++) {
                    synchronized (print) { // 3个线程都使用print对象做锁, 以保证只有一个线程在打印
                        // state!=1, 说明此时尚未到线程1打印, 线程1将调用print的wait()方法等待, 直到被唤醒
                        while (state != 1) {
                            try {
                                print.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        print.print(); // 打印数字
                        state = 2; // 接下来将轮到线程2打印

                        /*
                         * notifyAll()方法唤醒在print上等待的所有线程（线程2和线程3）,
                         * 同时线程1将退出同步代码块, 释放print对象锁. 因此3个线程将再次竞争print锁
                         * 假如线程1或线程3竞争到资源, 由于state不为1或3, 线程1或线程3将很快再次wait等待,
                         * 释放出刚到手的print对象锁. 只有线程2可以通过state判定,
                         * 所以线程2一定是执行下次打印任务的线程.
                         */
                        print.notifyAll();
                    }
                }
            }
        }, "Thread-01").start();

        /*
         * 线程2
         */
        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (print) {
                    for (int i = 0; i < 5; i++) {
                        while (state != 2) {
                            try {
                                print.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        print.print();
                        state = 3;
                        print.notifyAll();
                    }
                }
            }
        }, "Thread-02").start();

        /*
         * 线程3
         */
        new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (print) {
                    for (int i = 0; i < 5; i++) {
                        while (state != 3) {
                            try {
                                print.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        print.print();
                        state = 1;
                        print.notifyAll();
                    }
                }
            }
        }, "Thread-03").start();
    }
}

结果：

Thread-01 : 1
Thread-01 : 2
Thread-01 : 3
Thread-02 : 4
Thread-02 : 5
Thread-02 : 6
Thread-03 : 7
Thread-03 : 8
Thread-03 : 9
Thread-01 : 10
Thread-01 : 11
Thread-01 : 12
Thread-02 : 13
Thread-02 : 14
Thread-02 : 15
Thread-03 : 16
Thread-03 : 17
Thread-03 : 18
Thread-01 : 19
Thread-01 : 20
Thread-01 : 21
Thread-02 : 22
Thread-02 : 23
Thread-02 : 24
Thread-03 : 25
Thread-03 : 26
Thread-03 : 27
Thread-01 : 28
Thread-01 : 29
Thread-01 : 30
Thread-02 : 31
Thread-02 : 32
Thread-02 : 33
Thread-03 : 34
Thread-03 : 35
Thread-03 : 36
Thread-01 : 37
Thread-01 : 38
Thread-01 : 39
Thread-02 : 40
Thread-02 : 41
Thread-02 : 42
Thread-03 : 43
Thread-03 : 44
Thread-03 : 45