Java多线程同步

Java多线程同步

一、线程同步问题

       当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。因此多线程同步就是要解决这个问题。以下案例详细说明。

案例描述：
       在电影院卖票中，假设一共有5张电影票，现在有三个线程同时，同时在卖电影票。以下是代码实现。
代码实现：

 public static void main(String[] args) {
     
        Runnable  run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
     
       private int count = 5;
        @Override
        public void run() {
     
            while(count>0){
     
                System.out.println("正在准备买票");
                try {
     
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，余票："+count);
            }
        }
    }

运行结果：

正在准备买票
正在准备买票
正在准备买票
出票成功，余票：2
正在准备买票
出票成功，余票：2
正在准备买票
出票成功，余票：2
正在准备买票
出票成功，余票：-1
出票成功，余票：-1
出票成功，余票：-1

       从以上结果中发现，余票数本应大于0，由于多个线程同时访问同一个变量，既有读又有写操作，导致变量值的状态出现混乱，最后余票出现了-1。

二、同步问题解决方法

方法一：同步代码块

代码实现：

        public static void main(String[] args) {
     
            Runnable  run = new Ticket();
            new Thread(run).start();
            new Thread(run).start();
            new Thread(run).start();
        }
        static class Ticket implements Runnable{
     
            private int count = 5;
            private Object o = new Object();
            @Override
            public void run() {
     
                while(true) {
     
                    synchronized (o) {
     
                        if(count>0) {
     
                            System.out.println(Thread.currentThread().getName()+"正在准备买票");
                            try {
     
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
     
                                e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + count);
                        }else{
     
                           return;
                        }
                    }
                }

运行结果

Thread-0正在准备买票
Thread-0出票成功，余票：4
Thread-0正在准备买票
Thread-0出票成功，余票：3
Thread-2正在准备买票
Thread-2出票成功，余票：2
Thread-2正在准备买票
Thread-2出票成功，余票：1
Thread-2正在准备买票
Thread-2出票成功，余票：0

方法二：同步方法

代码实现：

  public static void main(String[] args) {
     
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
     
        private int count = 5;
        @Override
        public void run() {
     
            while (true) {
     
                boolean flag = sale();
                if (!flag) return;
            }
        }
        public synchronized boolean sale() {
     
            if (count > 0) {
     
                System.out.println(Thread.currentThread().getName() + "正在准备买票");
                try {
     
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "出票成功，余票：" + count);
                return true;
            }
            return false;
        }
    }

运行结果：

Thread-0正在准备买票
Thread-0出票成功，余票：4
Thread-2正在准备买票
Thread-2出票成功，余票：3
Thread-2正在准备买票
Thread-2出票成功，余票：2
Thread-2正在准备买票
Thread-2出票成功，余票：1
Thread-2正在准备买票
Thread-2出票成功，余票：0

方法三： 显示锁

代码实现：

    public static void main(String[] args) {
     
        Runnable  run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
     
        private int count = 5;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
     
            while(true) {
     
                    l.lock();
                    if(count>0) {
     
                        System.out.println(Thread.currentThread().getName()+"正在准备买票");
                        try {
     
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
     
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票：" + count);
                    }else{
     
                        return;
                    }
                    l.unlock();
                }
            }
        }

运行结果：

Thread-0正在准备买票
Thread-0出票成功，余票：4
Thread-0正在准备买票
Thread-0出票成功，余票：3
Thread-0正在准备买票
Thread-0出票成功，余票：2
Thread-0正在准备买票
Thread-0出票成功，余票：1
Thread-0正在准备买票
Thread-0出票成功，余票：0

三、显示锁与隐式锁

      以上方法一和方法二属于隐式锁Synchronized，方法三属于显示锁Lock,以下说明一下显示锁和隐式锁的区别。
1.出身不同
      Synchronized:Java中的关键字，是由JVM来维护的。是JVM层面的锁。
      Lock：是JDK5以后才出现的具体的类。使用lock是调用对应的API。是API层面的锁
      Synchronized是底层是通过monitorenter进行加锁（底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中，JVM才会调用monitory对象的）；通过monitorexit来退出锁的。
      lock是通过调用对应的API方法来获取锁和释放锁的。
2.使用方式不同
       Synchronized是隐式锁。Lock是显示锁。
       所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。
       在使用Synchronized关键字的时候，我们使用者根本不用写其他的代码，然后程序就能够获取锁和释放锁了。那是因为当Synchronized代码块执行完成之后，系统会自动的让程序释放占用的锁。Synchronized是由系统维护的，如果非逻辑问题的话话，是不会出现死锁的。
       在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock.lock()。释放锁：unlock方法。需要配合tyr/finaly语句块来完成。
3.等待是否可中断
       Synchronized是不可中断的。除非抛出异常或者正常运行完成
       Lock可以中断的。中断方式：
1.调用设置超时方法tryLock(long timeout ,timeUnit unit)
2.调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断
4.加锁的时候是否可以公平
       Synchronized;非公平锁
       lock：两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
       true：公平锁
       false：非公平锁
5.锁绑定多个条件来condition
       Synchronized:没有。要么随机唤醒一个线程；要么是唤醒所有等待的线程。
       Lock:用来实现分组唤醒需要唤醒的线程，可以精确的唤醒，而不是像Synchronized那样，不能精确唤醒线程。