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());
    }
}