当多个线程同时操作同一个共享资源时就会出现线程安全问题，将会导致数据不一致。因此，需要使用一些手段来保证共享资源的准确性。下面以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的苹果，显然是不对的。
用synchronized关键字修饰方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
public synchronized void eat() {
if (num > 0) {
try {
//导致一个资源信息被多个用户同时拿到
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "吃了编号为" + num + "的苹果");
num--;
}
}
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--;
}
}
}
在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();
}
}
以生产者-消费者模型为例：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。同样地，当队列空时，消费者也必须等待，等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。
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()));
}
}
}
}
}
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作，即这几种行为要么同时完成，要么都不完成。在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只有如下作用：
1.保证内存可见性
2.禁止指令重排序
在网上看到很多博文说，volatile关键字能够保证多线程的同步，这是错误的。尽管volatile关键字可以保证内存可见性和有序性，但不能保证原子性。