Java多线程07——JUC并发包03
1 线程的锁的synchronized、Lock、volatile区别
1.1 synchronized 和 volatile 区别
用法：
- volatile 关键字解决的是变量在多个线程之间的可见性；
- synchronized 关键字解决的是多个线程之间访问共享资源的同步性；
- 多线程访问 volatile 时，程序不会发生阻塞；在访问 synchronized 修饰的方法或代码块时，会出现阻塞；
- volatile 能保证变量在多个线程之间的可见性，但无法保证原子性；synchronized 可以保证数据操作的原子性，也可以间接保证数据的可见性，会将线程中私有内存和公有内存的数据进行同步。
比如我们使用信用卡消费，在消费中如果银行对卡片进行了冻结，那么扣款就应该会被拒绝。
此时就需要所有线程都能看到这个卡片状态的变化才行，否则就会造成用户损失。
要让这个状态被有线程看到，就需要使用 volatile 来修饰该变量。
扣款就更好理解了，如果不对账户的扣款动作进行加锁，账户相同的一笔钱可以被重复消费，将会造成银行的损失。加上锁之后，所有扣款行为将在这里串行进行，消费一笔扣减一笔，避免账户透支或者重复支付。
使用场景：
- volatile关键字只能用于修饰变量；
- synchronized 关键字可以修饰方法，代码块。
1.2 synchronized 和 Lock 区别
实现
Lock 是一个接口，而 synchronized 是 Java 中的关键字，由内置语言实现。
异常处理机制
synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁发生；
Lock 在发生异常时，如果没有主动通过 unlock() 方法去释放锁，则很可能造成死锁，因此使用 Lock 时需要在 finally 块中增加手动释放锁的语句。
synchronized{
语句块;
}
Lock lock = new ReentrantLock()
lock.lock();
lock.unLock();lock() 和 unlock() 必须成对存在。
效率
Lock 可以提高多个线程进行读操作的效率（读写锁）。
2 线程的读写分离机制
ReadWriteLock 是读写锁：
- 维护了一对相关的锁“读取锁”和“写入锁”，一个用于读取操作，另一个用于写入操作。
- 读取锁，用于只读操作，它是共享锁，能同时被多个线程获取。
- 写入锁，用于写入操作，它是独占锁，写入锁只能被一个线程锁获取。
- 不能同时存在读取锁和写入锁，可以同时进行读/读操作，但不能同时读/写、写/写操作。
2.1 创建账号类
public class MyCount {
private String id;//账号
private int cash;//账户余额
public MyCount(String id, int cash) {
this.id = id;
this.cash = cash;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//读取操作
public int getCash() {
System.out.println(Thread.currentThread().getName() + " getcash, cash=" + cash);
return cash;
}
//写入操作
public void setCash(int cash) {
System.out.println(Thread.currentThread().getName() + " setcash, cash=" + cash);
this.cash = cash;
}
}2.2 创建用户信息类
在用户信息类中声明了读写锁，
并在读取方法中创建读取锁，
在写入方法中创建写入锁，
所有锁在使用完后，均需要手动关闭锁。
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class User {
private String name;
private MyCount myCount;
//声明读写锁
private ReadWriteLock readWriteLock;
public User(String name, MyCount myCount) {
this.name = name;
this.myCount = myCount;
this.readWriteLock = new ReentrantReadWriteLock();
}
//查询余额
public void getCash(){
new Thread(){
@Override
public void run() {
//创建读取锁
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " getCash start");
myCount.getCash();
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " getCash end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//手动关闭锁
readWriteLock.readLock().unlock();
}
}
}.start();
}
//设置余额
public void setCash(final int cash){
new Thread(){
@Override
public void run() {
//创建写入锁
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + " setCash start");
myCount.setCash(cash);
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " setCash end");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//手动关闭锁
readWriteLock.writeLock().unlock();
}
}
}.start();
}
}2.3 创建测试类
在测试类中创建用户及账户，并对账户信息使用多线程进行读取和写入操作。
public class Test {
public static void main(String[] args) {
//创建账户
MyCount myCount = new MyCount("abcd12", 5000);
//创建用户，并指定账户
User user = new User("小张", myCount);
for (int i = 0; i < 3; i++) {
user.getCash();
user.setCash((i + 1) * 1000);
}
}
}2.4 输出结果
Thread-0 getCash start Thread-0 getcash, cash=5000 Thread-2 getCash start Thread-2 getcash, cash=5000 Thread-2 getCash end Thread-0 getCash end Thread-1 setCash start Thread-1 setcash, cash=1000 Thread-1 setCash end Thread-4 getCash start Thread-4 getcash, cash=1000 Thread-4 getCash end Thread-5 setCash start Thread-5 setcash, cash=3000 Thread-5 setCash end Thread-3 setCash start Thread-3 setcash, cash=2000 Thread-3 setCash end
在输出的结果中，可以看到：
读取操作 getCash ，在 Thread-0 执行时，但未执行完，Thread-2 也同时进入到了读取操作，它们正在并行执行；
写入操作 setCash ，所有线程均从 start 到 end，中间并未有其他线程进入，属于独占执行。
