Java中多线程访问冲突的解决方式
当时用多线程访问同一个资源时，非常容易出现线程安全的问题，例如当多个线程同时对一个数据进行修改时，会导致某些线程对数据的修改丢失。因此需要采用同步机制来解决这种问题。
第一种 同步方法
第二种 同步代码块
第三种 使用特殊成员变量（volatile 成员变量）实现线程同步（前提是对成员变量的操作是原子操作）
第四种 使用Lock接口（java.util.concurrent.locks包）
第五种 使用线程局部变量（thread-local）解决多线程对同一变量的访问冲突，而不能实现同步（ThreadLocal类）
第六种 使用阻塞队列实现线程同步（java.util.concurrent包）
第七种 使用原子变量实现线程同步 （java.util.concurrent.atomic包）
第一种 同步方法
同步方法即使用 synchronized关键字修饰的方法。在Java语言中，每个对象都有一个内置的对象锁与之相关联，该锁会保护整个方法，即对象在任何时候只允许被一个线程所拥有，当一个线程调用对象的一段synchronized代码时，首先需要获得这个锁，然后去执行相应的代码，执行结束，释放锁。synchronized关键字也可以以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。
synchronized关键字主要有两种用法：synchronized方法和synchronized块。此外该关键字还可以作用于静态方法、类或某个实例，但这都对程序的效率有很大的影响。
给一个方法增加synchronized关键字之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的抽象方法。
synchronized方法，在方法的声明前加入synchronized关键字。例如
package com.test.multiThread;
public class Bank {
private int account = 0;
public int getAccount(){
return account;
}
// 同步方法
public synchronized void save(int money){
this.account += money;
}
}
=================================
package com.test.multiThread;
public class MyThread implements Runnable {
private Bank bank;
public MyThread(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.save(1);
//bank.save01(1);
//bank.save02(1);
}
}
=================================
package com.test.multiThread;
import java.util.ArrayList;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException {
Bank bank = new Bank();
System.out.println(bank.getAccount());
ArrayList<Thread> list = new ArrayList<>();
for (int i = 0; i < 100000; i++){
list.add(new Thread(new MyThread(bank)));
}
for (Thread thread: list){
thread.start();
}
for (Thread thread: list){
thread.join();
}
System.out.println(bank.getAccount());
}
}只要把多线程访问的资源的操作放到multiThreadAccess方法中，就能够保证这个方法在同一时刻只能被一个线程访问，从而保证了多线程访问的安全性。然而当一个方法的方法体规模非常大时，把该方法声明为synchronized会大大影响程序的执行效率。为了提高程序的执行效率，Java语言提供了synchronized块。
第二种 同步代码块
即synchronized关键字修饰的语句块。被synchronized修饰的语句块会自动被加上内置锁，从而实现同步。
同步是一种高开销的操作，因此应该尽量减少同步的内容，通常没有必要使用同步方法，使用同步代码块来同步关键代码即可。
可以把任意的代码块声明为synchronized，也可以制定上锁的对象，有非常高的灵活性。用法如下
package com.test.multiThread;
public class Bank {
private int account = 0;
public int getAccount(){
return account;
}
// 同步代码块
public void save(int money){
synchronized (this){
this.account += money;
}
}
}
===============================
package com.test.multiThread;
public class MyThread implements Runnable {
private Bank bank;
public MyThread(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.save(1);
}
}
===============================
package com.test.multiThread;
import java.util.ArrayList;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException {
Bank bank = new Bank();
System.out.println(bank.getAccount());
ArrayList<Thread> list = new ArrayList<>();
for (int i = 0; i < 100000; i++){
list.add(new Thread(new MyThread(bank)));
}
for (Thread thread: list){
thread.start();
}
for (Thread thread: list){
thread.join();
}
System.out.println(bank.getAccount());
}
}
当使用synchronized来修饰某个共享资源的时候，如果线程Thread01在执行synchronized代码，另外一个线程Thread02也要同时执行同一对象的统一synchronized代码时，线程Thread02将要等到线程Thread01执行成后才能继续执行。在这种情况下，可以使用wait()方法和notify()方法。
在synchronized代码被执行期间，线程可以调用对象的wait()方法，释放对象锁，进入等待状态，并且可以调用notify()方法或者notifyAll()方法通知正在等待的而其他线程，notify()唤醒一个线程（等待队列中的第一个线程），并允许它去获得锁，而notifyAll()方法唤醒所有等待这个对象的线程，并允许它们去竞争获得锁。
第三种 使用特殊成员变量（volatile 成员变量）实现线程同步（前提是对成员变量的操作是原子操作）
volatile是一个类型修饰符，被设计用来修饰被不同线程访问和修饰的变量。当变量没有被volatile修饰时，线程读取数据时可能会从缓存中去读取，如果其他线程修改了该变量，则无法读取到修改后的数据。当变量被volatile修饰时，线程每次使用时都会直接到内存中提取，而不会利用缓存，从而保证了数据的同步。
volatile关键字主要目的是放置编译器对代码的优化，使得每次使用数据的时候都从内存里提取，而不是缓存，保证获得的数据是最新被修改的数据。但是volatile不能保证操作的原子性，一般不能替代synchronized代码块，除非对变量的操作是原子操作的情况下才可以使用volatile。
① volatile关键字为成员变量的访问提供了一种免锁机制，但要保证对成员变量的操作是原子操作的情况下才能使用
② volatile关键字相当于告诉虚拟机该成员变量可能会被其他线程修改
③ 每次使用被volatile修饰的成员变量都要从内存提取，重新计算，而不会使用寄存机器中的值
④ volatile不会提供任何原子操作，不能保证线程安全
⑤ volatile不能用来修饰final类型的变量
⑥ 使用volatile会降低程序的执行效率
Java中原子性保证：Java内存模型只保证了基本读取和复制是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock保证任一时刻只有一个线程执行该代码，那么自然就不存在原子性问题了，从而保证了原子性。
Java中可见性保证：synchronized和Lock、volatile三种，推荐使用synchronized方式，volatile有局限，适合某个特定场合。
第四种 使用Lock接口（java.util.concurrent.locks包）
JDK5新增了一个java.util.concurrent.locks包来支持同步。该包中提供了Lock接口以及它的一个实现类ReentrantLock（重入锁）
Lock接口也可以用来实现多线程的同步，其提供了如下方法来实现多线程的同步
public abstract void lock() // 以阻塞方式来获得锁，即如果获得了锁就立即返回，如果其他线程持有锁，当前线程等待，直到获取锁后返回。当前线程会一直处于阻塞状态，且会忽略interrupt（）方法
public abstract boolean tryLock() // 以非阻塞的方式获得锁，即尝试性的去获取锁，如果获得锁就返回true，否则返回false
public abstract boolean tryLock(long time, TimeUnit unit) // 如果在给定时间内获得锁，返回true，否则返回false
public abstract void lockInterruptibly // 如果获得锁，则立即返回，如果没有获得锁，则当前线程会处于休眠状态，直到获得锁，或者当前线程被其他线程中断（会收到InterruptedException异常）。
public abstract void unlock // 释放锁ReentrantLock类的构造方法
public ReentrantLock() // 创建一个ReentrantLock实例
public ReentrantLock(boolean fair) // 创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用使用Lock接口实现多线程同步的例子
package com.test.multiThread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Bank {
private int account = 0;
private Lock lock = new ReentrantLock(); // 声明这个重入锁
public int getAccount(){
return account;
}
public void save(int money){
lock.lock(); // 以阻塞方式获得锁
try {
account += money;
} finally {
lock.unlock(); // 释放锁
}
}
}
=============================
package com.test.multiThread;
public class MyThread implements Runnable {
private Bank bank;
public MyThread(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.save(1);
}
}
=============================
package com.test.multiThread;
import java.util.ArrayList;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException {
Bank bank = new Bank();
System.out.println(bank.getAccount());
ArrayList<Thread> list = new ArrayList<>();
for (int i = 0; i < 100000; i++){
list.add(new Thread(new MyThread(bank)));
}
for (Thread thread: list){
thread.start();
}
for (Thread thread: list){
thread.join();
}
System.out.println(bank.getAccount());
}
}第五种 使用线程局部变量（thread-local）解决多线程对同一变量的访问冲突，而不能实现同步 （ThreadLocal类）
public class ThreadLocal<T> extends Object如果使用ThreadLocal来管理变量，则每一个使用该变量的线程都会获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。所以对于同线程对共享变量的操作互不影响。
public class ThreadLocal<T>
extends Object
常用方法
public ThreadLocal() // 构造方法
public T get() // 返回次线程局部变量的当前线程副本中的值
public void set(T value) // 将次线程局部变量的当前线程副本中的值设置为value
protected T initialValue() // 返回次线程局部变量的当前线程的初始值
public void remove() //Thread-local与同步机制的比较：
1）两者都是为了解决多线程中相同变量的访问冲突问题
2）Thread-local采用“空间换时间”方法，同步机制采用“时间换空间”的方式
使用Thread-local的例子
package com.test.multiThread;
public class Bank {
private static ThreadLocal<Integer> account = ThreadLocal.withInitial(() -> 0);
public void save(int money){
account.set(account.get() + money);
}
public int getAccount(){
return account.get();
}
}
============================
package com.test.multiThread;
public class MyThread implements Runnable {
private Bank bank;
public MyThread(Bank bank){
this.bank = bank;
}
@Override
public void run() {
for (int i = 1; i < 10; i++){
bank.save(i);
}
System.out.println("Thread-local中的值: " + bank.getAccount());
}
}
============================
package com.test.multiThread;
import java.util.ArrayList;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException {
Bank bank = new Bank();
System.out.println("原始值：" + bank.getAccount());
ArrayList<Thread> list = new ArrayList<>();
for (int i = 0; i < 10; i++){
list.add(new Thread(new MyThread(bank)));
}
for (Thread thread: list){
thread.start();
}
for (Thread thread: list){
thread.join();
}
System.out.println("原始值：" + bank.getAccount());
}
}结果：改变的只是线程中变量的值，线程结束后Thread-local变量就销毁了
第六种 使用阻塞队列实现线程同步（java.util.concurrent包）
在JDK5提供的java.util.concurrent包中的 Class LinkedBlockingQueue<E> 可以实现线程的同步。
LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。其常用方法如下：
public LinkedBlockingQueue() //创建一个容量为Interger.MAX_VALUE的LinkedBlockingQueue
public int size() // 返回队列中的元素个数
public void put(E e) throws InterruptedException // 在队尾添加一个元素，如果队列满则阻塞
public E take() throws InterruptedException // 返回并移除对首元素，如果队列空则阻塞使用阻塞队列实现生产者-消费者。总的来说生产者的速度和消费者的速度相同，但是因为阻塞队列的缘故，不需要控制阻塞，当阻塞对列满的时候，生产者线程就会被阻塞，直到不再满；反之亦然，当消费者线程多于生产者线程时，消费者速度大于生产者速度，当队列为空时，就会阻塞消费者线程，直到队列非空。
package com.test.multiThread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class WorkDesk {
private BlockingQueue<String> desk = new LinkedBlockingQueue<>(10);
public void washDish() throws InterruptedException{
desk.put("盘子");
}
public String useDish() throws InterruptedException{
return desk.take();
}
}
=================================
package com.test.multiThread;
public class Producer implements Runnable {
private String producerName;
private WorkDesk workDesk;
public Producer(String producerName, WorkDesk workDesk){
this.producerName = producerName;
this.workDesk = workDesk;
}
@Override
public void run() {
try {
while (true) {
workDesk.washDish();
System.out.println(producerName + "洗好一个盘子");
Thread.sleep(1000);
}
} catch (Exception e){
e.printStackTrace();
}
}
}
=================================
package com.test.multiThread;
public class Consumer implements Runnable {
private String consumerName;
private WorkDesk workDesk;
public Consumer(String consumerName, WorkDesk workDesk){
this.consumerName = consumerName;
this.workDesk = workDesk;
}
@Override
public void run() {
try {
while (true) {
workDesk.useDish();
System.out.println(consumerName + "使用一个盘子");
Thread.sleep(1000);
}
} catch (Exception e){
e.printStackTrace();
}
}
}
=================================
package com.test.multiThread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestBlockingQueue {
public static void main(String[] args){
WorkDesk workDesk = new WorkDesk();
ExecutorService service = Executors.newCachedThreadPool();
Producer producer01 = new Producer("生产者-1-", workDesk);
Producer producer02 = new Producer("生产者-2-", workDesk);
Consumer consumer01 = new Consumer("消费者-1-", workDesk);
Consumer consumer02 = new Consumer("消费者-2-", workDesk);
service.submit(producer01);
service.submit(producer02);
service.submit(consumer01);
service.submit(consumer02);
}
}
第七种 使用原子变量实现线程同步（java.util.concurrent.atomic包）
需要使用线程同步的根本原因在于对普通变量的操作不是原子的。
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作，即这几步要么同时完成，要么都不完成。
在JDK5中提供的java.util.concurrent.atomic包中提供了创建原子类型变量的工具类，使用这些工具类能够简化线程同步。
package com.test.multiThread;
import java.util.concurrent.atomic.AtomicInteger;
public class Bank {
private AtomicInteger account = new AtomicInteger(0); // 创建具有给定初始值的新的AtomicInteger
public int getAccount(){
return account.get(); // 获取当前值
}
public void save(int money){
account.addAndGet(money); // 以原子方式将给定值与当前值相加
}
}
================================
package com.test.multiThread;
public class MyThread implements Runnable {
private Bank bank;
public MyThread(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.save(1);
}
}
================================
package com.test.multiThread;
import java.util.ArrayList;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException {
Bank bank = new Bank();
System.out.println("原始值：" + bank.getAccount());
ArrayList<Thread> list = new ArrayList<>();
for (int i = 0; i < 100000; i++){
list.add(new Thread(new MyThread(bank)));
}
for (Thread thread: list){
thread.start();
}
for (Thread thread: list){
thread.join();
}
System.out.println("线程执行完后：" + bank.getAccount());
}
}
