并发编程杂记注意点

最新推荐文章于 2022-02-16 20:44:05 发布

lianchaozhao

最新推荐文章于 2022-02-16 20:44:05 发布

阅读量145

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_40809627/article/details/103793890

版权

java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

注意：本文以java为编程记录

并发问题：指的是多个线程共同对数据（包括变量或代码中的数据等等）同时进行读写和写写操作时，产生的数据不统一问题，导致数据并发出现问题。

解决方式：一般对访问的代码加锁和对变量值以volatile修饰。

1、java 两种锁synchronized和lock

1.1、代码加锁synchronized 的方式

（1）synchronized解释
synchronized是java中的一个关键字，也就是说是Java语言内置的特性。如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁。

（2）释放锁的条件
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时JVM会让线程自动释放锁。

（3）synchronized 存在风险:
1)、获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了等情况下没有释放锁。其他线程便只能干巴巴地等待，影响程序执行效率。
2）、用synchronized 关键字加锁之后，无法解决读操作时线程之间发生冲突问题。（因为读读操作不会有线程多并发的问题）
3）、synchronized 相比Lock，不支持知道是否成功获取到锁的状态，
总体说lock 是比synchronized 支持更加功能，更加好用加锁的方式。

1.2、代码lock的加锁的方式

Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问，Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

lock是一个接口，一般我们具体应用他的实现类ReentrantLock，或重写他的方法。
java.util.concurrent.locks包下常用的类

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    }

1）、Lock接口中每个方法的使用（包含四种方法）
lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()是用来获取锁的。 unLock()方法是用来释放锁的

lock()
方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

tryLock()
方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

tryLock
(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

lockInterruptibly()
方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
注意：当一个线程获取了锁之后，是不会被interrupt()方法中断的。
因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。
而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

1、ReentrantLock 实现类。（“可重入锁”。）具体代码的使用情况参考下面。
例子1，lock()的正确使用方法
见代码MyLockTest

例子2，tryLock()的使用方法
见代码MyTryLock

例子3，lockInterruptibly()响应中断的使用方法：
见代码MyInterruptibly

2、ReadWriteLock
ReadWriteLock也是一个接口，在它里面只定义了两个方法

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();
 
    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。

ReentrantReadWriteLock
ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

下面通过几个例子来看一下ReentrantReadWriteLock具体用法。
例子1：假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果
见代码MySynchronizedReadWrite

在这里插入图片描述

例子2：改成用读写锁的话：
见代码MyReentrantReadWriteLock

在这里插入图片描述
注意:当使用读写锁时要注意下面两种情况：（1）如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。（2）如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

总结：Lock和synchronized的选择
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
　　5）Lock可以提高多个线程进行读操作的效率。
　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

Volatile

volatile 关键字保证任何线程在读取volatile修饰变量的时候，读取的都是变量的最新数据。所以具有读的可视性，另外，还能够为long和double的读取和写入提供原子性，此外，volatile还可以保证有序性。所以在并发的场景中我们很多情况下对读写并发变量用Volatile 修饰。
使用方式。注意一下使用的区分

// 对一个域加上volatile，域可以确保可视性和有序性
private volatile int b;

// 对long和double加上volatile，可以使如下的读取和写入具有原子性。
private volatile long a;
public long getA(){ return a;}
public void setA(A a){ this.a = a;}

注意一般数据拥有：了可视化、顺序性、原子性就是拥有了线程安全的数据。（todo 错误烦请指出）

注意：关于Volatile的非原子性：
在Java中，只有对基本类型（除了long和double，但是long和 double经volatile修饰后读取和写入会具有原子性）的变量的
读取和写入才会确保有原子性，并且不包括自增这类跟之前值相关的操作，原因如下：

volatile int num = 0;
public void doAddOne() {
  num++;
  // 自增包括两个步骤：
  // 1. 读取num的值 2. num+1 写入修改后的值
  // 假设线程A在读取num值的时候，被挂起，这个时候线程B读取num的值
  // 线程B对num进行自增，结果为1
  // 这个时候，线程A恢复调度，对起初读取的num的值进行自增，结果也会1
  // 0经过两个自增，结果仍然为1，所以说volatile域并不能保证原子性
}

总结在vlatile 应用于自增过程中，由于自增工厂映射为底层路基需要多部操作（使得在valatile 在自增这样的操作情况下变得数据部可控），但在一般性的读写过程中是线程安全的（比如应用于标志位的读写这样的操作 volatile string= “true”）
上述具体例子代码：https://pan.baidu.com/s/1S5tMBVIS3_dmDEClphBsKg