多线程问题——轮流打印、死锁、读写锁实现

概述

最近阅读了《Java高并发实战》一书，也了解了一些多线程方面的知识，但是一直没有尝试过写Coding。毕竟纸上得来终觉浅，因此通过本篇文章，对多个线程轮流打印、死锁、读写锁的实现问题进行总结，算是对多线程的一种巩固。主要涉及到的知识点就是synchronized锁和wait、notify线程通信机制。

线程轮流打印

问题描述

给定三个线程，代码的逻辑顺序是A->B->C，每个线程内分别打印一条“This is x”语句，如何做到最终打印顺序是C->B->A。

问题思考

要把多个线程的执行顺序给安排上，听起来就感觉要加锁，某个线程加锁执行完成，释放锁再进行下一个线程的执行，这只能保证可以以一定的顺序执行而不会乱序，但是具体的顺序就需要引入一个变量，用于标识当前应该由几号线程进行打印。在每个线程内去不断轮询是否轮到自己打印，如果没有轮到自己打印就wait进入阻塞状态，当别的线程打印完后，自己被唤醒继续去轮询是否轮到自己打印，当轮到自己时候，打印完成修改变量，并唤醒其它的所有线程，让其它的线程去判断是否轮到自己打印。整个逻辑就是如此，如果需要轮流打印C->B->A多次，使用for循环调用orderThread.printX即可。

具体实现

public class OrderThread {
    private int orderNum = 3;
    public static void main(String[] args) {
        OrderThread orderThread = new OrderThread();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                orderThread.printA();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                orderThread.printB();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                orderThread.printC();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

    public synchronized void printA(){
        while (orderNum != 1) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 3;
        System.out.println("This is A");
        notifyAll();
    }

    public synchronized void printB() {
        while (orderNum != 2) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 1;
        System.out.println("This is B");
        notifyAll();
    }

    public synchronized void printC() {
        while (orderNum != 3) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 2;
        System.out.println("This is C");
        notifyAll();
    }
}

运行结果

This is C
This is B
This is A

线程轮流打印-拓展

问题描述

给定三个线程，代码的逻辑顺序是A->B->C，三个线程按照C->B->A的顺序轮流打印1-100。

问题思考

该问题是“线程轮流打印”问题的拓展，依然是三个线程轮流打印，只是打印的内容进行了改变，需要从1开始计数打印。这就需要我们设置一个全局变量，每个线程内都对该全局变量进行打印并进行加一操作，以便下一个线程能够打印出正确的数字。需要注意的是：在while循环和线程执行体内都需要对待打印的变量num进行判断。while循环中的num判断是为了多次调用print方法，线程执行体内的num判断是为了避免在调用print方法时num尚未达到100，但是print方法执行过程中num已经超出100的情况，如果取消掉线程执行体内的num判断，程序会打印1-102。

具体实现

public class ThreadPrint {
    private int orderNum = 3;
    public static int num = 1;
    public static void main(String[] args) {
        ThreadPrint orderThread = new ThreadPrint();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (num <= 100) {
                    orderThread.printA();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (num <= 100) {
                    orderThread.printB();
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (num <= 100) {
                    orderThread.printC();
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

    public synchronized void printA(){
        while (orderNum != 1) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 3;
        if (num <= 100) {
            System.out.println("This is A " + num);
        }
        num++;
        notifyAll();
    }

    public synchronized void printB() {
        while (orderNum != 2) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 1;
        if (num <= 100) {
            System.out.println("This is B " + num);
        }
        num++;
        notifyAll();
    }

    public synchronized void printC() {
        while (orderNum != 3) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        orderNum = 2;
        if (num <= 100) {
            System.out.println("This is C " + num);
        }
        num++;
        notifyAll();
    }
}

死锁

问题描述

给定两个线程，使得程序产生死锁。

问题思考

既然需要产生死锁，就必须考虑到死锁产生的条件。
我们来逐条分析一下死锁的产生条件：
1、互斥，要做到资源互斥，只需要给资源加个锁，每个时刻就只能有一个线程能够获取到该资源；
2、不可剥夺，一般对于正常的程序而言，除非发生中断或者程序故障，否则对于线程已获得的资源，在未使用完成之前都是不可剥夺的，只能在使用后自己释放；
3、请求和保持，意味着当前线程需要持有一个资源，并去请求另一个资源；
4、循环等待，由上述条件进行引申，意味着A线程持有资源1并请求资源2，B线程持有资源2并请求资源1，形成环路。
综上，我们只需要创建两个不可剥夺的资源，并在不同的线程中通过synchronized关键字，根据不同的顺序对资源进行持有，这样即可实现死锁。

具体实现

public class DeadTest {
    public static void main(String[] args) {
        DeadLock deadLock1 = new DeadLock(true);
        DeadLock deadLock2 = new DeadLock(false);
        Thread t1 = new Thread(deadLock1);
        Thread t2 = new Thread(deadLock2);
        t1.start();
        t2.start();
    }
}

class DeadLock implements Runnable {
    //用于标识两个线程
    private boolean flag;
    //两个资源
    static final Object obj1 = new Object();
    static final Object obj2 = new Object();
    public DeadLock(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if (flag) {
            while (true) {
                //保持1并请求2
                synchronized (obj1) {
                    System.out.println(Thread.currentThread().getName() + "持有obj1");
                    synchronized (obj2) {
                        System.out.println(Thread.currentThread().getName() + "持有obj2");
                    }
                }
            }
        } else {
            while (true) {
                //保持2并请求1
                synchronized (obj2) {
                    System.out.println(Thread.currentThread().getName() + "持有obj2");
                    synchronized (obj1) {
                        System.out.println(Thread.currentThread().getName() + "持有obj1");
                    }
                }
            }
        }
    }
}

读写锁

问题描述

实现一个读写锁。读锁可以在没有写锁时被多个线程同时持有，写锁是独占的，每次只能有一个写线程，但是可以有多个线程并发地读数据。

问题思考

如果我们读写共用一把锁，那么实际上整个程序的读写就是串行的，同一时刻只能有一个线程对数据进行读或写，效率显然比较低，读写锁比互斥锁允许对于共享数据更大程度的并发。读写锁主要是为了能够将读写分离，因为程序其实是允许同一时刻，多个线程同时读取数据的，只要在读的期间没有写操作，即可保证所有读线程都能读到一致的数据。因此我们需要考虑到读写锁的原则：
1、读读能共存；
2、读写不能共存；
3、写写不能共存。
那么对于读锁而言，如果当前有线程在进行写入操作，则进入等待状态，直到所有的写锁释放即可获得读锁；对于写锁而言，只要当前没有写锁存在，则优先预抢占到写锁，避免被其它线程抢占，是一种先来先服务的实现，但是此时还没有真正获得写锁，直到判断当前不存在读锁，才能真正获取到写锁进行数据的写入。无论对于读锁还是写锁而言，锁的释放直接对锁资源进行更新，然后通知其它所有线程即可。

具体实现

public class ReadWriteLockTest {
    public static void main(String[] args) {
        ReadWriteLockDemo readWriteLock = new ReadWriteLockDemo();
        //启动写线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                readWriteLock.write(1);
            }
        }, "Write1").start();
        //启动10个读线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    readWriteLock.read();
                }
            }).start();
        }
        //启动写线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                readWriteLock.write(2);
            }
        }, "Write2").start();
    }
}

class ReadWriteLockDemo {
    private ReadWriteLock readWriteLock = new ReadWriteLock();
    private int num = 0; //共享资源

    //读
    public void read() {
        try {
            readWriteLock.lockRead();
            System.out.println(Thread.currentThread().getName() + " read " + num);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.unlockRead();
        }
    }

    //写
    public void write(int number) {
        try {
            readWriteLock.lockWrite();
            this.num = number;
            System.out.println(Thread.currentThread().getName() + " write " + num);
        } catch (Exception e) {
            e.printStackTrace();
        }  finally {
            readWriteLock.unlockWrite();
        }
    }
}

class ReadWriteLock {
    private int readLock = 0;
    private int writeLock = 0;

    public synchronized void lockRead() throws Exception{
        while (writeLock > 0) {
            wait();
        }
        readLock++;
    }

    public synchronized void unlockRead() {
        readLock--;
        notifyAll();
    }

    public synchronized void lockWrite() throws Exception{
        while (writeLock > 0) {
            wait();
        }
        writeLock++;
        while (readLock > 0) {
            wait();
        }
    }

    public synchronized void unlockWrite() {
        writeLock--;
        notifyAll();
    }
}

运行结果

Write1 write 1
Thread-1 read 1
Thread-2 read 1
Thread-5 read 1
Thread-0 read 1
Thread-3 read 1
Thread-4 read 1
Thread-8 read 1
Thread-6 read 1
Thread-9 read 1
Thread-7 read 1
Write2 write 2

从程序的运行结果中可以看出，对于读操作而言，只有在写操作结束后才能进行，并且不能保证线程执行的先后顺序，因为读操作并不是互斥的；而对于写操作而言，在读锁和写锁全部释放之后才能进行。因此，Read线程必须在Write1线程完成并释放写锁后才能执行，并且所有Read线程的执行是无序的，Write2线程只能等待所有Read线程完成并释放读锁后才能执行。