java多线程同步的实现方式

1.什么时候会出现线程安全问题

当多个线程同时操作同一个共享资源时就会出现线程安全问题，将会导致数据不一致。因此，需要使用一些手段来保证共享资源的准确性。下面以A、B、C三个小盆友吃苹果为例子，演示下线程不安全的情况。

package com.wk.concurrent;

class Apple implements Runnable {
    private int num = 50;

    public void run() {
        for (int i = 0; i < 50; i++) {
            eat();
        }
    }

    public void eat() {
        if (num > 0) {
            try {
                //导致一个资源信息被多个用户同时拿到
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "吃了编号为" + num + "的苹果");
            num--;
        }
    }
}

public class ImplementDemo {
    public static void main(String[] args) {
        Apple a = new Apple();
        new Thread(a, "A").start();
        new Thread(a, "B").start();
        new Thread(a, "C").start();
    }
}

A、B、C三个小朋友都同时吃了编号为50的苹果，显然是不对的。

2.使用synchronized关键字

用synchronized关键字修饰方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

2.1修饰方法

 public synchronized void eat() {
        if (num > 0) {
            try {
                //导致一个资源信息被多个用户同时拿到
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "吃了编号为" + num + "的苹果");
            num--;
        }
    }

2.2 修饰代码块

 public void eat() {
        synchronized (this) {
            if (num > 0) {
                try {
                    //导致一个资源信息被多个用户同时拿到
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "吃了编号为" + num + "的苹果");
                num--;
            }
        }
    }

3.使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包，juc包是专为多线程和高并发来设计的。其中ReentrantLock（可重入锁）类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
下面以银行存取款为例，演示一下ReentrantLock的用法

package com.wk.concurrent;

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

public class SynchronizedThread {

    class Bank {

        private int account = 100;
        //声明锁
        private Lock lock = new ReentrantLock();

        public int getAccount() {
            return account;
        }

        public void save(int money) {
            lock.lock();
            try {
                account += money;
            } finally {
                lock.unlock();
            }

        }
    }

    class NewThread implements Runnable {
        private Bank bank;

        public NewThread(Bank bank) {
            this.bank = bank;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                // bank.save1(10);
                bank.save(10);
                System.out.println(i + "账户余额为：" + bank.getAccount());
            }
        }

    }

    /**
     * 建立线程，调用内部类
     */
    public void useThread() {
        Bank bank = new Bank();
        NewThread new_thread = new NewThread(bank);
        System.out.println("线程1");
        Thread thread1 = new Thread(new_thread);
        thread1.start();
        System.out.println("线程2");
        Thread thread2 = new Thread(new_thread);
        thread2.start();
        Thread thread3 = new Thread(new_thread);
        thread3.start();
    }

    public static void main(String[] args) {
        SynchronizedThread st = new SynchronizedThread();
        st.useThread();
    }

}

4.wait与notify方法

以生产者-消费者模型为例：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。同样地，当队列空时，消费者也必须等待，等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。
wait（）和notify（）方法是Object类中的两个方法。除了使用synchronized关键字来协调线程之间的执行状态，还可以使用这两个方法以另外一种方式来协调线程。这两个方法是非静态的，因为这两个方法是Object类中的方法，所以Java中所有的实例都可以调用这两个方法。
wait（）方法:它让执行此代码的线程进入挂起状态。如果在处于挂起状态时，因为某些原因挂起被打断了，那么该方法就会抛出一个InterruptedException的异常，这个异常和sleep方法抛出的异常是同一个类型。
notify（）方法：唤醒因为在同一个对象上调用wait（）而处于挂起状态的线程，让线程可以继续执行下去。
下面的代码，是一个生产者和消费者模型的代码：

package com.wk.concurrent;

import java.util.PriorityQueue;

public class ProducerAndConsumer {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);

    public static void main(String[] args) {
        ProducerAndConsumer test = new ProducerAndConsumer();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();

        producer.start();
        consumer.start();
    }

    class Consumer extends Thread {

        @Override
        public void run() {
            consume();
        }

        private void consume() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 0) {
                        try {
                            System.out.println("队列空，等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.poll(); //每次移走队首元素
                    queue.notify();
                    System.out.println("从队列取走一个元素，队列剩余" + queue.size() + "个元素");
                }
            }
        }
    }

    class Producer extends Thread {

        @Override
        public void run() {
            produce();
        }

        private void produce() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == queueSize) {
                        try {
                            System.out.println("队列满，等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notify();
                        }
                    }
                    queue.offer(1);
                    queue.notify();
                    System.out.println("向队列取中插入一个元素，队列剩余空间：" + (queueSize - queue.size()));
                }
            }
        }
    }
}

5.使用原子变量实现线程同步

原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作，即这几种行为要么同时完成，要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类。
还是以Bank存取钱为例子，只需替换章节3中Bank类即可：

class Bank {
        private AtomicInteger account = new AtomicInteger(100);
        public AtomicInteger getAccount() {
            return account;
        }
        public void save(int money) {
            account.addAndGet(money);
        }
    }

关于volatile关键字

volatile只有如下作用：
1.保证内存可见性
2.禁止指令重排序
在网上看到很多博文说，volatile关键字能够保证多线程的同步，这是错误的。尽管volatile关键字可以保证内存可见性和有序性，但不能保证原子性。